您的位置：首页 > Web前端

深度学习Caffe实战笔记（3）用AlexNet跑自己的数据

2018-03-18 15:29 726 查看

上一篇博客介绍了如何在caffe框架平台下，用LeNet网络训练车牌识别数据，今天介绍用AlexNet跑自己的数据，同样基于windows平台下，会比基于Ubuntu平台下麻烦一些，特别是后面的Siamese网络，说起Siamese网络真是一把辛酸一把泪啊，先让我哭一会，，，，，哭了5分钟，算了，Siamese网络的苦水等以后再倒吧，言归正传，开始train。

在caffe平台下，实现用Alexnet跑自己的数据步骤和上一篇的步骤差不多，可以说几乎一样。。。。。

1、准备数据

在caffe根目录下data文件夹新建一个文件夹，名字自己起一个就行了，我起的名字是cloth，在cloth文件夹下新建两个文件夹，分别存放train和val数据，在train文件夹下存放要分类的数据，要分几类就建立几个文件夹，分别把对应的图像放进去。（当然，也可以把所有的图像都放在一个文件夹下，只是在标签文件中标明就行）。

然后建立train数据集对应的标签txt文件。同样，在val文件夹下存放验证数据，并建立验证图像对应的txt标签文件。

2、转换数据

编译成功的caffe根目录下bin文件夹下有一个convert_imageset.exe文件，用来转换数据，在cloth文件夹下新建一个脚本文件，内容：

mtrainldb和mvalldb分别是转化好的数据集文件，既caffe需要的文件。这样在cloth文件夹下会生成两个文件夹：

这里面存储的就是生成的数据文件。

3、计算均值

在cloth文件夹下新建一个计算均值的脚本文件，内容如下：

用到的computer_image_mean也是bin目录下生成的一个可执行文件，用来计算均值，mtrainldb是存放训练数据的文件夹，mimg_mean_binaryproto就是要生成的均值文件。双击运行后会生成mimg_mean_binaryproto文件，这个文件就是计算出来的均值文件。

4、开始训练

同样，在cloth文件夹下，新建一个train脚本文件，文件内容如下：

这个就不过多解释了吧，solver就是Alexnet的超参文件，打开后如下：

net: "train_val.prototxt"   #需要用哪个网络训练
test_iter: 1000
test_interval: 1000
base_lr: 0.01              #初始化学习率
lr_poli
1fa47
cy: "step"          #学习策略，每stepsize之后，将学习率乘以gamma
gamma: 0.1   #学习率变化因子
stepsize: 100000  #每stpesize之后降低学习率
display: 20
max_iter: 450000  #最大迭代次数
momentum: 0.9    #动量，上次参数更新的权重
weight_decay: 0.0005   #权重衰减量
snapshot: 10000    #每10000次保存一次模型结果
snapshot_prefix: "cloth"  #模型保存路径
solver_mode: GPU   #CPU或者GPU训练，这里使用CPU，所以需要把GPU改成CPU

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[/code]

打开train_val.prototxt，内容如下：

name: "AlexNet"
layer {
name: "data"
type: "Data"
top: "data"
top: "label"
include {
phase: TRAIN
}
transform_param {
mirror: true
crop_size: 227
mean_file: "mimg_mean.binaryproto" #均值文件
}
data_param {
source: "mtrainldb"  #训练数据
batch_size: 256
backend: LMDB
}
}
layer {
name: "data"
type: "Data"
top: "data"
top: "label"
include {
phase: TEST
}
transform_param {
mirror: false
crop_size: 227
mean_file: "mimg_mean.binaryproto"  #均值文件
}
data_param {
source: "mvaldb"   #验证数据
batch_size: 50
backend: LMDB
}
}
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: 11
stride: 4
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 0
}
}
}
layer {
name: "relu1"
type: "ReLU"
bottom: "conv1"
top: "conv1"
}
layer {
name: "norm1"
type: "LRN"
bottom: "conv1"
top: "norm1"
lrn_param {
local_size: 5
alpha: 0.0001
beta: 0.75
}
}
layer {
name: "pool1"
type: "Pooling"
bottom: "norm1"
top: "pool1"
pooling_param {
pool: MAX
kernel_size: 3
stride: 2
}
}
layer {
name: "conv2"
type: "Convolution"
bottom: "pool1"
top: "conv2"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 2
kernel_size: 5
group: 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: "norm2"
type: "LRN"
bottom: "conv2"
top: "norm2"
lrn_param {
local_size: 5
alpha: 0.0001
beta: 0.75
}
}
layer {
name: "pool2"
type: "Pooling"
bottom: "norm2"
top: "pool2"
pooling_param {
pool: MAX
kernel_size: 3
stride: 2
}
}
layer {
name: "conv3"
type: "Convolution"
bottom: "pool2"
top: "conv3"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 384
pad: 1
kernel_size: 3
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 0
}
}
}
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: 384
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: 256
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.005
}
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.5
}
}
layer {
name: "fc7"
type: "InnerProduct"
bottom: "fc6"
top: "fc7"
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.005
}
bias_filler {
type: "constant"
value: 0.1
}
}
}
layer {
name: "relu7"
type: "ReLU"
bottom: "fc7"
top: "fc7"
}
layer {
name: "drop7"
type: "Dropout"
bottom: "fc7"
top: "fc7"
dropout_param {
dropout_ratio: 0.5
}
}
layer {
name: "fc8"
type: "InnerProduct"
bottom: "fc7"
top: "fc8"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
inner_product_param {
num_output: 2       #注意：这里需要改成你要分成的类的个数
weight_filler {
type: "gaussian"
std: 0.01
}
bias_filler {
type: "constant"
value: 0
}
}
}
layer {
name: "accuracy"
type: "Accuracy"
bottom: "fc8"
bottom: "label"
top: "accuracy"
include {
phase: TEST
}
}
layer {
name: "loss"
type: "SoftmaxWithLoss"
bottom: "fc8"
bottom: "label"
top: "loss"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
[/code]

网络协议中需要注意的地方我都做了说明，其它的一些内容就不多做介绍了，想要了解的学友自行查资料吧。。。。

双击train.bat开始训练吧。

5、测试

同样，测试需要一个类别标签文件，category.txt，

在这里介绍一下类别文件的作用，第一个数就是训练时打的标签，后面那个是标签对应的类别名称，我这里为了方便写了0和1，其实应该把后面的0和1改成long sleve和short sleve，以便于测试的时候能直接显示出是长袖或者短袖。

写一个test脚本，

classification是bin目录下一个可执行文件，用于caffe中的分类。第二个是测试需要的协议，第三个我们训练好的模型，第四个是均值文件，第五个是类别标签，第六个是需要测试的图像。打开测试需要的deploy.prororxt，内容如下：

name: "AlexNet"
input: "data"
input_dim: 10
input_dim: 3         #数据
input_dim: 227
input_dim: 227
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: 11
stride: 4
}
}
layer {
name: "relu1"
type: "ReLU"
bottom: "conv1"
top: "conv1"
}
layer {
name: "norm1"
type: "LRN"
bottom: "conv1"
top: "norm1"
lrn_param {
local_size: 5
alpha: 0.0001
beta: 0.75
}
}
layer {
name: "pool1"
type: "Pooling"
bottom: "norm1"
top: "pool1"
pooling_param {
pool: MAX
kernel_size: 3
stride: 2
}
}
layer {
name: "conv2"
type: "Convolution"
bottom: "pool1"
top: "conv2"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 2
kernel_size: 5
group: 2
}
}
layer {
name: "relu2"
type: "ReLU"
bottom: "conv2"
top: "conv2"
}
layer {
name: "norm2"
type: "LRN"
bottom: "conv2"
top: "norm2"
lrn_param {
local_size: 5
alpha: 0.0001
beta: 0.75
}
}
layer {
name: "pool2"
type: "Pooling"
bottom: "norm2"
top: "pool2"
pooling_param {
pool: MAX
kernel_size: 3
stride: 2
}
}
layer {
name: "conv3"
type: "Convolution"
bottom: "pool2"
top: "conv3"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 384
pad: 1
kernel_size: 3
}
}
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: 384
pad: 1
kernel_size: 3
group: 2
}
}
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: 256
pad: 1
kernel_size: 3
group: 2
}
}
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
}
}
layer {
name: "relu6"
type: "ReLU"
bottom: "fc6"
top: "fc6"
}
layer {
name: "drop6"
type: "Dropout"
bottom: "fc6"
top: "fc6"
dropout_param {
dropout_ratio: 0.5
}
}
layer {
name: "fc7"
type: "InnerProduct"
bottom: "fc6"
top: "fc7"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
inner_product_param {
num_output: 4096    #改成和训练网络一致
}
}
layer {
name: "relu7"
type: "ReLU"
bottom: "fc7"
top: "fc7"
}
layer {
name: "drop7"
type: "Dropout"
bottom: "fc7"
top: "fc7"
dropout_param {
dropout_ratio: 0.5
}
}
layer {
name: "fc8"
type: "InnerProduct"
bottom: "fc7"
top: "fc8"
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
inner_product_param {
num_output: 2       #输出的类别个数
}
}
layer {
name: "prob"
type: "Softmax"
bottom: "fc8"
top: "prob"
}

表示为短袖的概率为100%.测试图片为：

这两个博客一个是完成lenet网络训练，一个是完成Alexnet网络训练，那么举二反无穷，不管用什么网路，用自己的数据来跑基本上就是这个步骤了对不对，即使有不同，也是大同小异，只需要做小量修改即可，到时候需要具体情况具体分析。。。。。。。

写在后面的话：

话说写博客也不是一件轻松的事情啊，好累，好费时间，在我学习的过程中有好多都是从别的同学的博客里学习到的，所以我很愿意把我学习到的东西分享给别人，因为我也是从一头雾水，问谁谁不理的时候一步步走来的。说到分享，昨天看了一个上本科时学院的书记转发的一个朋友圈文章，叫“为什么层次越高的人，计较的越少”，就谈到了愿不愿分享的问题，有的人觉得自己辛苦得来的东西，害怕别人知道了，不愿意告诉别人怎么做的，其实这样的人格局实在太小，殊不知你告诉别人的只不过是一个结果，在你探索过程中得到的分析能力，思维方式，你的知识结构别人是拿不去的！你在乎的，往往能反映出你的水准，为什么层次越高的人，反而计较的越少呢？不是说他有多么宽容，而是有些事根本入不了他的眼。愿不愿意分享，就能看出一个人的眼界和格局，而眼界和格局往往才是决定一个人盛衰成败的关键！共勉。。。。。。

<link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/production/markdown_views-68a8aad09e.css">
</div>

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航