1:神经网络中，我们通过最小化神经网络来训练网络，所以在训练时最后一层是损失函数层（LOSS），

在测试时我们通过准确率来评价该网络的优劣，因此最后一层是准确率层（ACCURACY）。

但是当我们真正要使用训练好的数据时，我们需要的是网络给我们输入结果，对于分类问题，我们需要获得分类结果，如下右图最后一层我们得到

的是概率，我们不需要训练及测试阶段的LOSS，ACCURACY层了。

下图是能过$CAFFE_ROOT/python/draw_net.py绘制$CAFFE_ROOT/models/caffe_reference_caffnet/train_val.prototxt   , $CAFFE_ROOT/models/caffe_reference_caffnet/deploy.prototxt，分别代表训练时与最后使用时的网络结构。

我们一般将train与test放在同一个.prototxt中，需要在data层输入数据的source，

而在使用时.prototxt只需要定义输入图片的大小通道数据参数即可，如下图所示，分别是

$CAFFE_ROOT/models/caffe_reference_caffnet/train_val.prototxt   , $CAFFE_ROOT/models/caffe_reference_caffnet/deploy.prototxt的data层

训练时, solver.prototxt中使用的是rain_val.prototxt

1
./build/tools/caffe/train
-solver ./models/bvlc_reference_caffenet/solver.prototxt

使用上面训练的网络提取特征，使用的网络模型是deploy.prototxt

1
./build/tools/extract_features.bin
models/bvlc_refrence_caffenet.caffemodel models/bvlc_refrence_caffenet/deploy.prototxt

     。。

2：

（1）介绍 *_train_test.prototxt文件与 *_deploy.prototxt文件的不http://blog.csdn.net/sunshine_in_moon/article/details/49472901

（2）生成deploy文件的Python代码：http://www.cnblogs.com/denny402/p/5685818.html

*_train_test.prototxt文件：这是训练与测试网络配置文件

 
*_deploy.prototxt文件：这是模型构造文件
 

在博文http://www.cnblogs.com/denny402/p/5685818.html     中给出了生成 deploy.prototxt文件的Python源代码，但是每个网络不同，修改起来比较麻烦，下面给出该博文中以mnist为例生成deploy文件的源代码，可根据自己网络的设置做出相应修改：（下方代码未测试）

# -*- coding: utf-8 -*-

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

root='/home/xxx/'

deploy=root+'mnist/deploy.prototxt'    #文件保存路径

def create_deploy():

    #少了第一层，data层

    conv1=L.Convolution(bottom='data', kernel_size=5, stride=1,num_output=20, pad=0,weight_filler=dict(type='xavier'))

    pool1=L.Pooling(conv1, pool=P.Pooling.MAX, kernel_size=2, stride=2)

    conv2=L.Convolution(pool1, kernel_size=5, stride=1,num_output=50, pad=0,weight_filler=dict(type='xavier'))

    pool2=L.Pooling(conv2, pool=P.Pooling.MAX, kernel_size=2, stride=2)

    fc3=L.InnerProduct(pool2, num_output=500,weight_filler=dict(type='xavier'))

    relu3=L.ReLU(fc3, in_place=True)

    fc4 = L.InnerProduct(relu3, num_output=10,weight_filler=dict(type='xavier'))

    #最后没有accuracy层，但有一个Softmax层

    prob=L.Softmax(fc4)

    return to_proto(prob)

def write_deploy():

    with open(deploy, 'w') as f:

        f.write('name:"Lenet"\n')

        f.write('input:"data"\n')

        f.write('input_dim:1\n')

        f.write('input_dim:3\n')

        f.write('input_dim:28\n')

        f.write('input_dim:28\n')

        f.write(str(create_deploy()))

if __name__ == '__main__':

    write_deploy()

用代码生成deploy文件还是比较麻烦。我们在构建深度学习网络时，肯定会先定义好训练与测试网络的配置文件——*_train_test.prototxt文件，我们可以通过修改*_train_test.prototxt文件 来生成 deploy 文件。以cifar10为例先简单介绍一下两者的区别。

（1）deploy 文件中的数据层更为简单，即将*_train_test.prototxt文件中的输入训练数据lmdb与输入测试数据lmdb这两层删除，取而代之的是，

  1. layer {
  2. name: "data"
  3. type: "Input"
  4. top: "data"
  5. input_param { shape: { dim: 1 dim: 3 dim: 32 dim: 32 } }
  6. }
 
注：shape: { dim: 1 dim: 3 dim: 32 dim: 32 }代表含义：
 
shape {

  dim: 1  #num，可自行定义

  dim: 3  #通道数，表示RGB三个通道

  dim: 32   #图像的长和宽，通过 *_train_test.prototxt文件中数据输入层的crop_size获取

  dim: 32
 

（2）卷积层和全连接层中weight_filler{}与bias_filler{}两个参数不用再填写，因为这两个参数的值，由已经训练好的模型*.caffemodel文件提供。如下所示代码，将*_train_test.prototxt文件中的weight_filler、bias_filler全部删除。

layer {  # weight_filler、bias_filler删除

name: "ip2"

type: "InnerProduct"

bottom: "ip1"   top: "ip2"

param {

lr_mult: 1   #权重w的学习率倍数

}

param {     lr_mult: 2    #偏置b的学习率倍数

}

inner_product_param {     num_output: 10

weight_filler {       type: "gaussian"       std: 0.1     }    

bias_filler {       type: "constant"     }

}

}

删除后变为

  1. layer {
  2. name: "ip2"
  3. type: "InnerProduct"
  4. bottom: "ip1"
  5. top: "ip2"
  6. param {
  7. lr_mult: 1
  8. }
  9. param {
  10. lr_mult: 2
  11. }
  12. inner_product_param {
  13. num_output: 10
  14. }
  15. }
 
（3）输出层的变化  
     1）没有了test模块测试精度 ，将该层删除     
     2）输出层
 
1）*_deploy.prototxt文件的构造和*_train_test.prototxt文件的构造最为明显的不同点是，deploy文件没有test网络中的test模块，只有训练模块，即将*_train_test.prototxt中最后部分的test模块测试精度删除，即将如下代码删除。
 
  1. layer {                                  #删除该层
  2. name: "accuracy"
  3. type: "Accuracy"
  4. bottom: "ip2"
  5. bottom: "label"
  6. top: "accuracy"
  7. include {
  8. phase: TEST
  9. }
  10. }

2） 输出层

*_train_test.prototxt文件

  1. layer{
  2. name: "loss"   #注意此处层名称与下面的不同
  3. type: "SoftmaxWithLoss"  #注意此处与下面的不同
  4. bottom: "ip2"
  5. bottom: "label"    #注意标签项在下面没有了，因为下面的预测属于哪个标签，因此不能提供标签
  6. top: "loss"
  7. }
 
*_deploy.prototxt文件
[python]
  1. layer {
  2. name: "prob"
  3. type: "Softmax"
  4. bottom: "ip2"
  5. top: "prob"
  6. }

注意在两个文件中输出层的类型都发生了变化一个是SoftmaxWithLoss，另一个是Softmax。另外为了方便区分训练与应用输出，训练是输出时是loss，应用时是prob。

下面给出CIFAR10中的配置文件cifar10_quick_train_test.prototxt与其模型构造文件  cifar10_quick.prototxt 直观展示两者的区别。

cifar10_quick_train_test.prototxt文件代码

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
cifar10_quick_train_test.prototxt文件代码
 
name: "CIFAR10_quick"
 layer
{               #该层去掉
  name: "cifar"
   type: "Data"
   top: "data"
   top: "label"
   include
{
     phase:
TRAIN
   }
   transform_param
{
     mean_file: "examples/cifar10/mean.binaryproto"
   }
   data_param
{
     source: "examples/cifar10/cifar10_train_lmdb"
     batch_size:
100
     backend:
LMDB
   }
 }
 layer
{             #该层去掉
  name: "cifar"
   type: "Data"
   top: "data"
   top: "label"
   include
{
     phase:
TEST
   }
   transform_param
{
     mean_file: "examples/cifar10/mean.binaryproto"
   }
   data_param
{
     source: "examples/cifar10/cifar10_test_lmdb"
     batch_size:
100
     backend:
LMDB
   }
 }
 layer
{                        #将下方的weight_filler、bias_filler全部删除
  name: "conv1"
   type: "Convolution"
   bottom: "data"
   top: "conv1"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   convolution_param
{
     num_output:
32
     pad:
2
     kernel_size:
5
     stride:
1
     weight_filler
{
       type: "gaussian"
       std:
0.0001
     }
     bias_filler
{
       type: "constant"
     }
   }
 }
 layer
{
   name: "pool1"
   type: "Pooling"
   bottom: "conv1"
   top: "pool1"
   pooling_param
{
     pool:
MAX
     kernel_size:
3
     stride:
2
   }
 }
 layer
{
   name: "relu1"
   type: "ReLU"
   bottom: "pool1"
   top: "pool1"
 }
 layer
{                         #weight_filler、bias_filler删除
  name: "conv2"
   type: "Convolution"
   bottom: "pool1"
   top: "conv2"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   convolution_param
{
     num_output:
32
     pad:
2
     kernel_size:
5
     stride:
1
     weight_filler
{
       type: "gaussian"
       std:
0.01
     }
     bias_filler
{
       type: "constant"
     }
   }
 }
 layer
{
   name: "relu2"
   type: "ReLU"
   bottom: "conv2"
   top: "conv2"
 }
 layer
{
   name: "pool2"
   type: "Pooling"
   bottom: "conv2"
   top: "pool2"
   pooling_param
{
     pool:
AVE
     kernel_size:
3
     stride:
2
   }
 }
 layer
{                         #weight_filler、bias_filler删除
  name: "conv3"
   type: "Convolution"
   bottom: "pool2"
   top: "conv3"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   convolution_param
{
     num_output:
64
     pad:
2
     kernel_size:
5
     stride:
1
     weight_filler
{
       type: "gaussian"
       std:
0.01
     }
     bias_filler
{
       type: "constant"
     }
   }
 }
 layer
{
   name: "relu3"
   type: "ReLU"
   bottom: "conv3"
   top: "conv3"
 }
 layer
{
   name: "pool3"
   type: "Pooling"
   bottom: "conv3"
   top: "pool3"
   pooling_param
{
     pool:
AVE
     kernel_size:
3
     stride:
2
   }
 }
 layer
{                       #weight_filler、bias_filler删除
  name: "ip1"
   type: "InnerProduct"
   bottom: "pool3"
   top: "ip1"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   inner_product_param
{
     num_output:
64
     weight_filler
{
       type: "gaussian"
       std:
0.1
     }
     bias_filler
{
       type: "constant"
     }
   }
 }
 layer
{                              # weight_filler、bias_filler删除
  name: "ip2"
   type: "InnerProduct"
   bottom: "ip1"
   top: "ip2"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   inner_product_param
{
     num_output:
10
     weight_filler
{
       type: "gaussian"
       std:
0.1
     }
     bias_filler
{
       type: "constant"
     }
   }
 }
 layer
{                                  #将该层删除
  name: "accuracy"
   type: "Accuracy"
   bottom: "ip2"
   bottom: "label"
   top: "accuracy"
   include
{
     phase:
TEST
   }
 }
 layer
{                                 #修改
  name: "loss"       #---loss 
修改为  prob
   type: "SoftmaxWithLoss"             #
SoftmaxWithLoss 修改为 softmax
   bottom: "ip2"
   bottom: "label"          #去掉
  top: "loss"
 }
 
 
 
 
 
以下为cifar10_quick.prototxt
 
layer
{               #将两个输入层修改为该层
  name: "data"
   type: "Input"
   top: "data"
   input_param
{ shape: { dim: 1 dim: 3 dim: 32 dim: 32 } }      #注意shape中变量值的修改，CIFAR10中的 *_train_test.protxt文件中没有 crop_size
 }
 layer
{
   name: "conv1"
   type: "Convolution"
   bottom: "data"
   top: "conv1"
   param
{
     lr_mult:
1   #权重W的学习率倍数
}
   param
{
     lr_mult:
2   #偏置b的学习率倍数
  }
   convolution_param
{
     num_output:
32
     pad:
2   #加边为2
    kernel_size:
5
     stride:
1
   }
 }
 layer
{
   name: "pool1"
   type: "Pooling"
   bottom: "conv1"
   top: "pool1"
   pooling_param
{
     pool:
MAX    #Max Pooling
    kernel_size:
3
     stride:
2
   }
 }
 layer
{
   name: "relu1"
   type: "ReLU"
   bottom: "pool1"
   top: "pool1"
 }
 layer
{
   name: "conv2"
   type: "Convolution"
   bottom: "pool1"
   top: "conv2"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   convolution_param
{
     num_output:
32
     pad:
2
     kernel_size:
5
     stride:
1
   }
 }
 layer
{
   name: "relu2"
   type: "ReLU"
   bottom: "conv2"
   top: "conv2"
 }
 layer
{
   name: "pool2"
   type: "Pooling"
   bottom: "conv2"
   top: "pool2"
   pooling_param
{
     pool:
AVE   #均值池化
    kernel_size:
3
     stride:
2
   }
 }
 layer
{
   name: "conv3"
   type: "Convolution"
   bottom: "pool2"
   top: "conv3"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   convolution_param
{
     num_output:
64
     pad:
2
     kernel_size:
5
     stride:
1
   }
 }
 layer
{
   name: "relu3"
   type: "ReLU"  #使用ReLU激励函数，这里需要注意的是，本层的bottom和top都是conv3>
   bottom: "conv3"
   top: "conv3"
 }
 layer
{
   name: "pool3"
   type: "Pooling"
   bottom: "conv3"
   top: "pool3"
   pooling_param
{
     pool:
AVE
 kernel_size:
3
     stride:
2
   }
 }
 layer
{
   name: "ip1"
   type: "InnerProduct"
   bottom: "pool3"
   top: "ip1"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   inner_product_param
{
     num_output:
64
   }
 }
 layer
{
   name: "ip2"
   type: "InnerProduct"
   bottom: "ip1"
   top: "ip2"
   param
{
     lr_mult:
1
   }
   param
{
     lr_mult:
2
   }
   inner_product_param
{
     num_output:
10
   }
 }
layer
{
   name: "prob"
   type: "Softmax"
   bottom: "ip2"
   top: "prob"
 }

3：

将train_val.prototxt 转换成deploy.prototxt

1.删除输入数据（如：type:data...inckude{phase: TRAIN}），然后添加一个数据维度描述。

  1. input: "data"
  2. input_dim: 1
  3. input_dim: 3
  4. input_dim: 224
  5. input_dim: 224
  6. force_backward: true
2.移除最后的<span style="line-height: 24px; color: rgb(68, 68, 68); font-family: "Open Sans", Helvetica, Arial, sans-serif; font-size: 14px;">“loss” 和“accuracy” 层，加入“prob”层。</span>

[plain]

  1. layers {
  2. name: "prob"
  3. type: SOFTMAX
  4. bottom: "fc8"
  5. top: "prob"
  6. }
如果train_val文件中还有其他的预处理层，就稍微复杂点。如下，在'data'层，在‘data’层和‘conv1’层<span style="line-height: 24px; color: rgb(68, 68, 68); font-family: "Open Sans", Helvetica, Arial, sans-serif; font-size: 14px;">(with <span style="margin: 0px; padding: 0px; border: 0px currentcolor; vertical-align: baseline;">bottom:”data”  / top:”conv1″). 插入一个层来计算输入数据的均值。</span></span>
  1. layer {
  2. name: “mean”
  3. type: “Convolution”
  4. <strong>bottom: “data”
  5. top: “data”</strong>
  6. param {
  7. lr_mult: 0
  8. decay_mult: 0
  9. }
  10. …}
<span style="line-height: 1.5; margin: 0px; padding: 0px; border: 0px currentcolor; vertical-align: baseline;">在deploy.prototxt文件中，“mean” 层必须保留，只是容器改变，相应的‘conv1’也要改变<span style="line-height: 24px; color: rgb(68, 68, 68); font-family: "Open Sans", Helvetica, Arial, sans-serif; font-size: 14px;"> ( <span style="margin: 0px; padding: 0px; border: 0px currentcolor; vertical-align: baseline;"><span style="line-height: 1.5; margin: 0px; padding: 0px; border: 0px currentcolor; vertical-align: baseline;">bottom:”mean”/ <span style="line-height: 24px; margin: 0px; padding: 0px; border: 0px currentcolor; vertical-align: baseline;">top:”conv1″ )。</span></span></span></span></span>

[plain]

  1. layer {
  2. name: “mean”
  3. type: “Convolution”
  4. <strong>bottom: “data”
  5. top: “mean“</strong>
  6. param {
  7. lr_mult: 0
  8. decay_mult: 0
  9. }
  10. …}

4：

生成deploy文件

如果要把训练好的模型拿来测试新的图片，那必须得要一个deploy.prototxt文件，这个文件实际上和test.prototxt文件差不多，只是头尾不相同而也。deploy文件没有第一层数据输入层，也没有最后的Accuracy层，但最后多了一个Softmax概率层。

这里我们采用代码的方式来自动生成该文件，以mnist为例。

deploy.py

# -*- coding: utf-8 -*-

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

root=‘/home/xxx/‘

deploy=root+‘mnist/deploy.prototxt‘    #文件保存路径

def create_deploy():

    #少了第一层，data层

    conv1=L.Convolution(bottom=‘data‘, kernel_size=5, stride=1,num_output=20, pad=0,weight_filler=dict(type=‘xavier‘))

    pool1=L.Pooling(conv1, pool=P.Pooling.MAX, kernel_size=2, stride=2)

    conv2=L.Convolution(pool1, kernel_size=5, stride=1,num_output=50, pad=0,weight_filler=dict(type=‘xavier‘))

    pool2=L.Pooling(conv2, pool=P.Pooling.MAX, kernel_size=2, stride=2)

    fc3=L.InnerProduct(pool2, num_output=500,weight_filler=dict(type=‘xavier‘))

    relu3=L.ReLU(fc3, in_place=True)

    fc4 = L.InnerProduct(relu3, num_output=10,weight_filler=dict(type=‘xavier‘))

    #最后没有accuracy层，但有一个Softmax层

    prob=L.Softmax(fc4)

    return to_proto(prob)

def write_deploy():

    with open(deploy, ‘w‘) as f:

        f.write(‘name:"Lenet"\n‘)

        f.write(‘input:"data"\n‘)

        f.write(‘input_dim:1\n‘)

        f.write(‘input_dim:3\n‘)

        f.write(‘input_dim:28\n‘)

        f.write(‘input_dim:28\n‘)

        f.write(str(create_deploy()))

if __name__ == ‘__main__‘:

    write_deploy()

运行该文件后，会在mnist目录下，生成一个deploy.prototxt文件。

这个文件不推荐用代码来生成，反而麻烦。大家熟悉以后可以将test.prototxt复制一份，修改相应的地方就可以了，更加方便。

 5：

Convert train_val.prototxt to deploy.prototxt

  1. Remove input datalayer and insert a description of input data dimension
  2. Remove “loss” and “accuracy” layer and insert “prob” layer at the end

Here is a google groups link.

If you have preprocessing layers, things get a bit more tricky.

For example, in train_val.prototxt, which includes the “data” layer, I insert a layer to calculate the mean over the channels of input data,

layer { name: “mean” type: “Convolution” bottom: “data” top: “data” param { lr_mult: 0 decay_mult: 0 }

…}

between “data” layer and “conv1” layer (with bottom:”data” / top:”conv1″).

In deploy.prototxt, the “mean” layer has to be retained, yet its container needs to be changed! i.e.

layer { name: “mean” type: “Convolution” bottom: “data” top: “mean“ param { lr_mult: 0 decay_mult: 0 }

…}

and the “conv1” layer needs to be changed accordingly, ( bottom:”mean”/ top:”conv1″ ).

It’s fine to use train_val.prototxt with “mean” layer using “data” container in the training phase, and use deploy.prototxt with “mean” layer using “mean” container in the testing phase in python. The learned caffemodel
can be loaded correctly.

【神经网络与深度学习】Caffe部署中的几个train-test-solver-prototxt-deploy等说明的更多相关文章

  1. 【神经网络与深度学习】【CUDA开发】【VS开发】Caffe+VS2013+CUDA7.5+cuDNN配置过程说明

    [神经网络与深度学习][CUDA开发][VS开发]Caffe+VS2013+CUDA7.5+cuDNN配置过程说明 标签:[Qt开发] 说明:这个工具在Windows上的配置真的是让我纠结万分,大部分 ...

  2. 【神经网络与深度学习】Caffe使用step by step：caffe框架下的基本操作和分析

    caffe虽然已经安装了快一个月了,但是caffe使用进展比较缓慢,果然如刘老师说的那样,搭建起来caffe框架环境比较简单,但是完整的从数据准备->模型训练->调参数->合理结果需 ...

  3. 【吴恩达课后测验】Course 1 - 神经网络和深度学习 - 第二周测验【中英】

    [中英][吴恩达课后测验]Course 1 - 神经网络和深度学习 - 第二周测验 第2周测验 - 神经网络基础 神经元节点计算什么? [ ]神经元节点先计算激活函数,再计算线性函数(z = Wx + ...

  4. 【吴恩达课后测验】Course 1 - 神经网络和深度学习 - 第一周测验【中英】

    [吴恩达课后测验]Course 1 - 神经网络和深度学习 - 第一周测验[中英] 第一周测验 - 深度学习简介 和“AI是新电力”相类似的说法是什么? [  ]AI为我们的家庭和办公室的个人设备供电 ...

  5. 【神经网络与深度学习】【Qt开发】【VS开发】从caffe-windows-visual studio2013到Qt5.7使用caffemodel进行分类的移植过程

    [神经网络与深度学习][CUDA开发][VS开发]Caffe+VS2013+CUDA7.5+cuDNN配置成功后的第一次训练过程记录<二> 标签:[神经网络与深度学习] [CUDA开发] ...

  6. 【腾讯Bugly干货分享】深度学习在OCR中的应用

    本文来自于腾讯bugly开发者社区,未经作者同意,请勿转载,原文地址:http://dev.qq.com/topic/5809bb47cc5e52161640c5c8 Dev Club 是一个交流移动 ...

  7. 人工智能深度学习Caffe框架介绍，优秀的深度学习架构

    人工智能深度学习Caffe框架介绍,优秀的深度学习架构 在深度学习领域,Caffe框架是人们无法绕过的一座山.这不仅是因为它无论在结构.性能上,还是在代码质量上,都称得上一款十分出色的开源框架.更重要 ...

  8. 【神经网络与深度学习】【CUDA开发】caffe-windows win32下的编译尝试

    [神经网络与深度学习][CUDA开发]caffe-windows win32下的编译尝试 标签:[神经网络与深度学习] [CUDA开发] 主要是在开发Qt的应用程序时,需要的是有一个使用的库文件也只是 ...

  9. （转）神经网络和深度学习简史（第一部分）：从感知机到BP算法

    深度|神经网络和深度学习简史(第一部分):从感知机到BP算法 2016-01-23 机器之心 来自Andrey Kurenkov 作者:Andrey Kurenkov 机器之心编译出品 参与:chen ...

  10. [DeeplearningAI笔记]神经网络与深度学习人工智能行业大师访谈

    觉得有用的话,欢迎一起讨论相互学习~Follow Me 吴恩达采访Geoffrey Hinton NG:前几十年,你就已经发明了这么多神经网络和深度学习相关的概念,我其实很好奇,在这么多你发明的东西中 ...

随机推荐

  1. Nginx解析PHP

    刚安装完PHP后,nginx是无法解析的,如果输入地址会直接下载文件,需要进行如下的设置 步骤 修改/etc/nginx/sites-available/default和cat /etc/nginx/ ...

  2. 【SQL-分组合并字符串】把相同分组的某个字段合并为同一个字符串（使用函数）

    场景:我要把同一个订单同一个客户同一个产品分组合并,同时把该产品所有的库位列举出来,合成一个字符串. 原始数据: 我要得到下面的结果: SQL如下: ==先建个方法== create function ...

  3. [转] Linux环境变量配置文件以及启动顺序

    转自:https://blog.csdn.net/bjnihao/article/details/51775854 一.环境变量配置文件: 对所有用户都起作用 /etc/profile /etc/pr ...

  4. NURBS 曲线和曲面参数化

    NURBS 曲线和曲面参数化 什么是参数? 参数是曲线或曲面上点的唯一数值(类似于坐标).通过参数,可以沿曲线的长度方向引用特定点.参数值越大,点在曲线方向上的距离越远. 就像空间中的点具有三个维度( ...

  5. linux环境下写C++操作mysql（一）

    /***************** connect.cpp g++ connect.cpp -o connect -I /usr/include/mysql/ -L /usr/lib/mysql/ ...

  6. Topcoder SRM 674 Div.2题解

    T1 解题思路 这题应该不是很难,主要是题意理解问题. 注意给出的两个数组里映射关系已经对应好了,只要判断是否为双射即可 参考程序 #include <bits/stdc++.h> usi ...

  7. Codeforces Round #201.C-Alice and Bob

    C. Alice and Bob time limit per test 2 seconds memory limit per test 256 megabytes input standard in ...

  8. HDU2433—Travel （BFS，最短路）

    Travel Time Limit: 10000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Sub ...

  9. Anaconda cheat sheet

    1 anaconda prompt 闪退的情况 在cmd中进入C:\ProgramData\Anaconda3\Scripts然后可以使用各种conda命令 2 anaconda 换源 # 方法参考 ...

  10. Docker入门-构建第一个Java程序

    定制镜像 准备一个没有第三方依赖的java web项目,可能参考示例maven结构项目: session-web.war 把该war上传到安装有docker软件的服务器上宿主目录下.在同级目录创建Do ...