利用caffe的Python接口生成prototxt文件

最新推荐文章于 2024-04-25 09:55:39 发布
最新推荐文章于 2024-04-25 09:55:39 发布
阅读量1.9k 收藏 2
点赞数 2
分类专栏： caffe 文章标签： caffe

Python版本：Python2.7
mnist数据集
博客来源：http://blog.csdn.net/c406495762/article/details/70306550

如何编译caffe的Python接口就不多说了
下面的代码可以一次生成Lenet网络训练所需的train.prototxt和test.prototxt,还有solver.prototxt

代码:

# -*- coding: UTF-8 -*-
import caffe                                                     #导入caffe包

def create_net(lmdb, mean_file, batch_size, include_acc=False):
    #网络规范
    net = caffe.NetSpec()
    #Data层
    net.data, net.label = caffe.layers.Data(source=lmdb, backend=caffe.params.Data.LMDB, batch_size=batch_size, ntop=2,
                                            transform_param = dict(mean_file=mean_file,scale= 0.00390625))
    #视觉层
    net.conv1 = caffe.layers.Convolution(net.data, num_output=20,kernel_size=5,weight_filler={"type": "xavier"},bias_filler={"type": "constant"})
    net.pool1 = caffe.layers.Pooling(net.conv1, pool=caffe.params.Pooling.MAX, kernel_size=2, stride=2)
    net.conv2 = caffe.layers.Convolution(net.pool1, kernel_size=5, stride=1,num_output=50, pad=0,weight_filler=dict(type='xavier'),bias_filler={"type": "constant"})
    net.pool2 = caffe.layers.Pooling(net.conv2, pool=caffe.params.Pooling.MAX, kernel_size=2, stride=2)
    #全连接层
    net.fc1 = caffe.layers.InnerProduct(net.pool2, num_output=500,weight_filler=dict(type='xavier'),bias_filler={"type": "constant"})
    net.fc_add1 = caffe.layers.InnerProduct(net.fc1, num_output=500,weight_filler=dict(type='xavier'),bias_filler={"type": "constant"})#没什么意义，加一层试试
    net.fc_add2 = caffe.layers.InnerProduct(net.fc_add1, num_output=500,weight_filler=dict(type='xavier'),bias_filler={"type": "constant"})#也没什么意义，再加一层试试
    #激活层
    net.relu1 = caffe.layers.ReLU(net.fc_add2, in_place=True)
    #dropout层
    net.drop3 = caffe.layers.Dropout(net.fc_add2, in_place=True)
    net.fc2 = caffe.layers.InnerProduct(net.fc_add2, num_output=10,weight_filler=dict(type='xavier'))
    #sofemax层
    net.loss = caffe.layers.SoftmaxWithLoss(net.fc2, net.label)
    #训练的prototxt文件不包括Accuracy层,测试的时候需要。
    if include_acc:
        net.acc = caffe.layers.Accuracy(net.fc2, net.label)
        return str(net.to_proto())

    return str(net.to_proto())

def write_net(mean_file,train_proto, train_lmdb, test_proto, val_lmdb):
    #写入prototxt文件
    with open(train_proto, 'w') as f:
        f.write(str(create_net(train_lmdb,mean_file,batch_size = 64)))
    #写入prototxt文件
    with open(test_proto, 'w') as f:
        f.write(str(create_net(val_lmdb,mean_file,batch_size = 100, include_acc = True)))

def write_sovler(my_project_root, solver_proto, train_proto, test_proto):
    sovler_string = caffe.proto.caffe_pb2.SolverParameter()                    #sovler存储
    sovler_string.train_net = train_proto                                    #train.prototxt位置指定
    sovler_string.test_net.append(test_proto)                                 #test.prototxt位置指定
    sovler_string.test_iter.append(100)                                        #10000/100 测试迭代次数
    sovler_string.test_interval = 938                                        #60000/64 每训练迭代test_interval次进行一次测试
    sovler_string.base_lr = 0.01                                            #基础学习率
    sovler_string.momentum = 0.9                                            #动量
    sovler_string.weight_decay = 5e-4                                        #权重衰减
    sovler_string.lr_policy = 'step'                                        #学习策略
    sovler_string.stepsize = 3000                                             #学习率变化频率
    sovler_string.gamma = 0.1                                                  #学习率变化指数
    sovler_string.display = 20                                                #每迭代display次显示结果
    sovler_string.max_iter = 9380                                            #10 epoch 938*10 最大迭代数
    sovler_string.snapshot = 938                                             #保存临时模型的迭代数
    sovler_string.snapshot_prefix = my_project_root + 'mnist/model/mnist'                #模型前缀
    sovler_string.solver_mode = caffe.proto.caffe_pb2.SolverParameter.GPU    #优化模式

    with open(solver_proto, 'w') as f:
        f.write(str(sovler_string))


#def train(solver_proto):
#    caffe.set_device(0)
#    caffe.set_mode_gpu()
#    solver = caffe.SGDSolver(solver_proto)
#    solver.solve()


if __name__ == '__main__':
    my_project_root = "F:/python/make_prototxt/"    #my-caffe-project目录
    train_lmdb = my_project_root + "mnist/data/mnist_train_lmdb"                #train_lmdb文件的位置
    val_lmdb = my_project_root + "mnist/data/mnist_test_lmdb"                    #val_lmdb文件的位置
    train_proto = my_project_root + "mnist/train.prototxt"                #保存train.prototxt文件的位置
    test_proto = my_project_root + "mnist/test.prototxt"                #保存test.prototxt文件的位置
    solver_proto = my_project_root + "mnist/solver.prototxt"            #保存solver.prototxt文件的位置
    mean_file = my_project_root + "mnist/data/trainMean.binaryproto"                          #均值文件的位置

    write_net(mean_file,train_proto, train_lmdb, test_proto, val_lmdb)
    print "生成train.prototxt test.prototxt成功"
    write_sovler(my_project_root, solver_proto, train_proto, test_proto)
    print "生成solver.prototxt成功"
   # train(solver_proto)
   # print "训练完成"

运行结果:
生成的train.prototxt

layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  transform_param {
    scale: 0.00390625
    mean_file: "F:/python/make_prototxt/mnist/data/trainMean.binaryproto"
  }
  data_param {
    source: "F:/python/make_prototxt/mnist/data/mnist_train_lmdb"
    batch_size: 64
    backend: LMDB
  }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  convolution_param {
    num_output: 20
    kernel_size: 5
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "pool1"
  top: "conv2"
  convolution_param {
    num_output: 50
    pad: 0
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "fc1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "fc1"
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc_add1"
  type: "InnerProduct"
  bottom: "fc1"
  top: "fc_add1"
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc_add2"
  type: "InnerProduct"
  bottom: "fc_add1"
  top: "fc_add2"
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "fc_add2"
  top: "fc_add2"
}
layer {
  name: "drop3"
  type: "Dropout"
  bottom: "fc_add2"
  top: "fc_add2"
}
layer {
  name: "fc2"
  type: "InnerProduct"
  bottom: "fc_add2"
  top: "fc2"
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "fc2"
  bottom: "label"
  top: "loss"
}

生成的test.prototxt

layer {
  name: "data"
  type: "Data"
  top: "data"
  top: "label"
  transform_param {
    scale: 0.00390625
    mean_file: "F:/python/make_prototxt/mnist/data/trainMean.binaryproto"
  }
  data_param {
    source: "F:/python/make_prototxt/mnist/data/mnist_test_lmdb"
    batch_size: 100
    backend: LMDB
  }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  convolution_param {
    num_output: 20
    kernel_size: 5
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "pool1"
  top: "conv2"
  convolution_param {
    num_output: 50
    pad: 0
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "fc1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "fc1"
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc_add1"
  type: "InnerProduct"
  bottom: "fc1"
  top: "fc_add1"
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "fc_add2"
  type: "InnerProduct"
  bottom: "fc_add1"
  top: "fc_add2"
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "fc_add2"
  top: "fc_add2"
}
layer {
  name: "drop3"
  type: "Dropout"
  bottom: "fc_add2"
  top: "fc_add2"
}
layer {
  name: "fc2"
  type: "InnerProduct"
  bottom: "fc_add2"
  top: "fc2"
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "fc2"
  bottom: "label"
  top: "loss"
}
layer {
  name: "acc"
  type: "Accuracy"
  bottom: "fc2"
  bottom: "label"
  top: "acc"
}

生成的solver.prototxt

train_net: "F:/python/make_prototxt/mnist/train.prototxt"
test_net: "F:/python/make_prototxt/mnist/test.prototxt"
test_iter: 100
test_interval: 938
base_lr: 0.01
display: 20
max_iter: 9380
lr_policy: "step"
gamma: 0.1
momentum: 0.9
weight_decay: 0.0005
stepsize: 3000
snapshot: 938
snapshot_prefix: "F:/python/make_prototxt/mnist/model/mnist"
solver_mode: GPU

接下来就可以训练了

Run_it_faraway
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在python中编写caffe的prototxt文件
tina的博客
05-16 6795
利用python可以创建caffe的网络定义的prototxt文件，利用这种方法的一个好处就是：可以保证training，testing和deploy网络的一致性！下面是利用python编写train和test的prototxt文件的一个小事例：import os from os.path import join import numpy as npimport caffe from caffe i
python程序生成prototxt文件.pdf
12-24
python程序⽣成prototxt⽂件 ⼀、前⾔ 了解到上⼀篇笔记的内容，就可以尝试⾃⼰编写python程序⽣成prototxt⽂件了，当然也可以直接创建⽂件进⾏编写，不过显然，使⽤ python⽣成这个配置⽂件更为简洁。之前已说过...
深度学习框架Caffe学习笔记(8)-BP神经网络算法
流云非晚的专栏
11-14 1万+
BP神经网络的计算流程为，先根据输入数据各个节点的权重偏向，计算出神经网络的输出（前向传播计算），通过计算输出与理想输出比较得到误差，再根据误差函数再各个节点的偏导数计算出各权重、偏向的调整量（反向传播计算）。该迭代过程循环进行，直到达到某些停止条件，如训练误差已经小到一定值。
Caffe——网络配置（prototxt文件）
小白一直白
09-20 1446
网络配置数据层卷积层池化层激活函数全连接层显示准确率层softmax层reshape层Dropout层 数据层 数据层是模型最底层，提供提供数据输入和数据从Blobs转换成别的格式进行保存输出，通常数据预处理(减去均值，放大缩小，裁剪和镜像等)也在这一层设置参数实现。 layer { name: "mnist" #名称 type: "Data" #输入的是LMDB数据，前面的create_mnist.sh做了转换 include: { phase:TRIAN #只在训练的时候才包括(测
探索pdoc：Python项目的文档生成利器
最新发布
gitblog_00071的博客
04-25 298
探索pdoc：Python项目的文档生成利器 项目地址:https://gitcode.com/pdoc3/pdoc pdoc是一个强大的开源工具，用于自动生成Python项目的API文档。它简洁、高效，以其易用性和丰富的功能为Python开发者提供了便捷的文档解决方案。 项目简介 pdoc的目标是自动化Python项目的文档构建过程，通过解析源代码中的注释和类型提示，生成易于阅读的HTML文档。...
利用caffe的pycaffe接口将caffemodel中的字段保存为prototxt
Run_it_faraway的博客
08-01 1724
使用str可以一次性将caffemodel中所有的的字段读出来 例如： # coding:utf-8 import _init_paths import caffe.proto.caffe_pb2 as caffe_pb2 caffemodel_filename = 'F:/caffe_new/caffe/caffe-master/data/mnist-test/mnist-models/
Caffe学习笔记(四)：使用pycaffe生成train.prototxt、test.prototxt文件
热门推荐
Jack-Cui
04-20 2万+
了解到上一篇笔记的内容，就可以尝试自己编写python程序生成prototxt文件了，当然也可以直接创建文件进行编写，不过显然，使用python生成这个配置文件更为简洁。之前已说过cifar10是使用cifar10_quick_solver.prototxt配置文件来生成model。
caffe用python产生prototxt文件
葫芦与瓢的博客
06-19 3284
caffe通过python写网络结构,通过python生成prototxt
SCNN-prototxt-generator:生成空间CNN caffe prototxt文件的脚本
05-13
空间CNN Prototxt生成器该脚本用于生成 caffe prototxt文件。如何使用运行run.sh生成Spatial CNN模块，然后修改参数。 “ --height”，“-width”和“ --channel”分别是最后一个特征图的行数，列数和通道数。 将...
Simulink-Caffe-Builder:使用Simulink（Matlab）作为可视化生成器来生成caffe prototxt文件
05-19
使用Simulink（Matlab）作为可视化生成器来生成caffe prototxt文件。 ＃＃＃概述： 通过手动构建在Caffe中构建不同的网络架构prototxt文件有点慢，并且容易出现复制粘贴错误。 鉴于Caffe的广泛采用及其非常模块化...
FDDB,测试自己训练的模型，如何生成FDDB 文件，详细细节
09-18
train_proto是训练模型的prototxt文件，train_model是训练模型的caffemodel文件，deploy_proto是部署模型的prototxt文件，save_model是合并的模型文件。 五、 使用MobilenetSSD模型生成FDDB文件 使用MobilenetSSD...
基于caffe的车辆定位1
08-08
它会搜索指定的输入图像目录`im_dir`，生成一个临时的`imlist.txt`文件，然后根据`base.prototxt`自动修改`source`和`meanfile`的路径，创建一个新的模型结构文件`exp.prototxt`。用户可以指定输出类型（`DRAW`、`...
python生成prototxt协议文件
qikaihuting的博客
03-15 766
#!/usr/bin/env python # -*- coding: utf-8 -*- import sys caffe_root = 'E:/ycsun/file/code/caffe/caffe-windows/Build/x64/Release/pycaffe/' sys.path.insert(0, caffe_root) import caffe from caffe import...
读懂 caffe的prototxt文件
weixin_38906715的博客
02-09 268
caffe的prototxt文件_OneCoder的博客-CSDN博客_prototxtname任取，表示这一层的名字type：层类型，如果是Data，表示数据来源是LevelDB后者LMDB，根据数据来源的不同，数据层的类型也不同，有些还是从磁盘中存储hdf5或者图片格式。top和bottom：top为此层输出，bottom为此层输入，在数据层中，至少有一个命名为data的top。如果有第二个t...
Python：caffe中Python生成prototxt文件
BigCowPeking
03-17 1039
Python：caffe中Python生成prototxt文件比如卷积的初始化参数:weight_filler=dict(type=’xavier’), 以及池化的参数:pool=P.Pooling.MAX 还有数据层的参数:spec.data,spec.label=L.ImageData(source=train_list,batch_size=batch_size,shuffle=True,n...
Caffe学习笔记(五)：使用pycaffe生成solver.prototxt文件并进行训练
Jack-Cui
04-20 1万+
转载请注明作者和出处：http://blog.csdn.net/c406495762 Python版本： Python2.7 运行平台： Ubuntu14.04
Caffe调用python接口生成prototxt（网络结构文件）
苦冲 ，开 了便淡╮
04-02 387
https://github.com/GeekLiB/caffe-model
使用Python生成caffe所需的solver.prototxt文件并进行训练
IT菜鸟
08-29 688
参考博客 Caffe学习笔记(五)：使用pycaffe生成solver.prototxt文件并进行训练 一、环境说明 操作系统：Ubuntu16.04 python版本：python2.7 虚拟环境：Anaconda 虚拟软件：VMware12 caffe下载地址：https://github.com/BVLC/caffe 二、准备工作 参考我的另外一篇博客使用Py...
caffe中train.prototxt中的python层（python_param）的解析
OGLD
09-18 740
Caffe通过Boost中的Boost.Python模块来支持使用Python定义Layer： 使用C++增加新的Layer繁琐、耗时而且很容易出错 开发速度与执行速度之间的trade-off 编译同时支持Python Layer的Caffe，方便更改使用。如果想要使用应进行以下配置： 如果是首次编译，修改Caffe根目录下的Makefile.cinfig，uncomment WITH_PYT...
如何将.cfg和.weight文件转化为.caffemodel和.prototxt文件，给我一套可行的方案
05-25
首先，需要明确一点，`.cfg`和`.weight`文件是Darknet框架的模型文件，而`.caffemodel`和`.prototxt`是Caffe框架的模型文件。因此，需要使用转换工具将Darknet模型转换成Caffe模型。 以下是一套可行的方案： 1. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值