2335人阅读
caffe框架（61）
mac下安装caffe可以参考之前的一篇wiki()，当然如果遇到其他问题请自行google。
对于各种linux系统，网上的教程已经非常多了。
2.caffe代码与架构层次简单介绍
caffe源码是Cpp语言的，基于一些外部的库，包括BLAS(矩阵计算)，CUDA(GPU驱动)，gflags,glog,boost,protobuf,hdf5,leveldb,lmdb等。
只要各个以来都安装完毕，编译的时候修改下caffe自带的Makefile.config（路径和编译选项的修改），即可编译整个工程。
caffe代码文件夹主要包括：
build &所有编译好的文件存放位置
data & 数据文件夹
docs & 教程和说明文件夹(建议好好阅读，部分内容讲的非常详细)
include & 包含文件夹，头文件
examples &各种demo的文件夹，相关应用可以参考或者直接使用对应的demo和配置
mnist 手写汉字识别 & cifar10 &场景识别 & imagenet 图片分类 & cpp_classification 分类的cpp接口文件 & feature_extraction提特征的demo文件夹
matlab &matlab对应的接口
python &python对应的接口
models &model文件的路径，一些训练好的model可以参考caffe官网model zoo：
tools & 一些工具
src &所有源代码存放位置
docs/tutorial 中的文件非常值得阅读，关于caffe 的架构和基本使用讲的很透彻，入门必读
3.caffe的一些应用
（1）网络训练参数调节，可以参考mnist或者cifar10中的demo。
& & & & 调参根据经验，或者参考docs/tutorial/solver.md
需要调节的参数(solver.prototxt)主要包括：
base_lr:初始学习率，这个是非常重要的一个参数；momentum:一般设置为0.9，如果base_lr特别低的话也可以设置为0.99或0.999等 & &weight_decay:默认0.005，可以适当调整，类似于正则化项； &
lr_policy:学习率变化策略，常见的有fixed（固定）， inv，step等，详细的说明见 & & &
或者参考源代码src/caffe/solver.cpp中的GetLerningRate函数
常见的调参方式包括：examples/mnist中的各种方式 fixed，inv，step等，或者cifar10中的quick两步调参的方法。
主要是控制初始的学学习率，并对应的调节学习率的策略，batch size需要适当控制大小
&其他参数：
test_iter：进行多少轮测试 &display：迭代多少次显示一次 &max_iter：最大迭代次数
snapshot：多少轮之后存一次结果 &snapshot_prefix：结果文件前缀 &&solver_mode：使用CPU还是GPU
（2）根据已知的网络进行fine－tune
fine－tune的好处是可以利用别人预先调节好的网络，适当微调网络结构和参数就可以用于自己的应用。
注意事项：0.fine－tune的网络和之前网络结构应该基本一致，特别是输入，不然对应层参数个数不同，会报错
& & & & & & & & & 1.训练的时候加入 &--weight &指定从哪个模型导入对应层的参数(根据名字)。
& & & & & &2.由于caffe是根据对应层的名字来寻找是否需要填充对应的参数，所以对于你需要导入参数的层，名字和原来网络保持不变，对于你需要自己调节的层，名字需要修改。
& & & & & &3.如果你修改了网络的结构( 比如由1000类分类改为28)，则对应层的名字需要改掉，不然会报错。
& & & & & &4.对于你要调节的层，学习率倍数lr_mult需要变大（10，20），其他层尽可能小；如果其他层不需要调节，可以置为0.
（3）使用cpp做分类
利用已经训练好的网络做分类也是一个非常常见的应用。
代码在examples/cpp_classification/classification.cpp &可执行文件在build/examples/cpp_classification/classification.bin
classification.cpp文件通过读入配置，权重，mean文件，图片，进行一次前向操作得到输出层的概率，然后给出分类结果。
基本函数是Predict和Classify。根据特定需求，加入了几个函数，并且改写了main函数可以通过文件列表读入图像，然后特征写入文件。
examples/cpp_classification/extract_feature.cpp：自己改写之后的classification.cpp包括分类和批量提特征功能
Normalize：做L2-norm归一化的辅助函数
FeatureAndPredict：同时提取特征(引用传递feature变量)和返回分类结果的函数，根据传入的string 提取对应层特征。
FeatureByLayerName：根据传入的string提取特定层特征的函数。
main：将所有参数在main中指定，同时调用提特征函数对读取文件中的图片进行特征提取并写入二进制文件中。
（4）特征提取
利用已经有的网络提取特定层的特征，可以使用examples/feature_extraction或者用上面（3）改写之后的extract_feature.cpp函数。
4.做OCR过程中遇到的一些坑和解决方案
（1）最开始调节网络总会发现各种莫名其妙的报错，例如lock，state等等；主要原因可能有一下几点：
& & & & &文件或者文件格式生成错误，配置文件格式错误：solver文件或者网络文件
（2）基本熟悉caffe之后就可以在特定网络的基础上进行调节了，此时常见的问题就是不收敛或者正确率不理想到情况。
& & & & & 一般解决思路：
检查lmdb或者leveldb是否生成错误，配置文件是否书写错误
观察loss变化情况，适当调整学习率和策略；
& & & & & & & & & & & &思考训练数据量，类别数，网络结构层数之间的关系，考虑分辨率数据量和网络的能力之间是否相互匹配；如果不合适可以考虑更换网络或者增加数据量。
& & & & （3）如果网络收敛，正确率也比较高的情况下，依然可能遇到问题
&& & & & & & & & &比如分类中正确率是对的，但是每次输出都概率不是0就是1，遇到这种问题多半是因为softmax之前一层的数据问题，解决方案：
& & & & & & & & &1）更换网络，增加数据量，或者在现有比较好的网络基础上做微调
& & & & & & & & &2）自己获得softmax之前的数据做softmax 变换：xi＝exp(xi-max)/sum(exp(xi-max))，减最大值是为了防止数值溢出，具体代码见examples/cpp_classification/classification.cpp的Predict函数。
& & & & & & & & &classification.cpp函数运行时间特别长，单张图像要几秒级别。
& & & & & & & & &这个原因是分类函数每次都会导入配置，时间很长，只要自己手动导入一次配置，然后再进行分类操作即可解决。代码见examples/cpp_classification/extract_feature.cpp
& & & & & & & &&如果一切正常比较大的网络运行时间可能在0.x秒级别，小一点的会在0.0x秒或者0.00x秒级别，但是很多时候比如滑窗这种潜在分类目标太多，运行速度依旧不能满足正常的需求
& & & & & & & &&&可以参考examples /extract _feature中的方法进行改进，批量读取图片做为一个batch，进行一次前向操作，代码待完成
（4）解决了0，1概率问题之后，直接用于滑窗，发现正确率依然非常低
造成这个问题的主要原因是分类器给出的置信概率往往不太靠谱，尽管分类正确率比较高。
解决方案是使用分类器给出分类，然后使用prototype原型的方法给出置信概率，经过这样改进之后，CNN＋svm＋prototype的验证码识别率可以超过传统方法。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：314168次
积分：4674
积分：4674
排名：第6384名
原创：85篇
转载：302篇
译文：10篇
评论：159条
研二在读，关注：深度学习，计算机视觉，机器学习，图像处理。博文主要是自己的一些总结。转载文章供资料学习（转载一些最新文章），如有侵权望告知。注：有些评论没有回复，最近比较忙不好意思。
(8)(35)(7)(14)(43)(57)(22)(16)(46)(24)(43)(42)(40)caffe程序自带有一张小猫图片，存放路径为caffe根目录下的 examples/images/cat.jpg, 如果我们想用一个训练好的caffemodel来对这张图片进行分类，那该怎么办呢？ 如果不用这张小猫图片，换一张别的图片，又该怎么办呢？如果学会了小猫图片的分类，那么换成其它图片，程序实际上是一样的。
开发caffe的贾大牛团队，利用imagenet图片和caffenet模型训练好了一个caffemodel, &供大家下载。要进行图片的分类，这个caffemodel是最好不过的了。所以，不管是用c++来进行分类，还是用python接口来分类，我们都应该准备这样三个文件：
1、caffemodel文件。&
& 可以直接在浏览器里输入地址下载，也可以运行脚本文件下载。下载地址为：
文件名称为：bvlc_reference_caffenet.caffemodel，文件大小为230M左右，为了代码的统一，将这个caffemodel文件下载到caffe根目录下的&models/bvlc_reference_caffenet/ 文件夹下面。也可以运行脚本文件进行下载：
# sudo ./scripts/download_model_binary.py models/bvlc_reference_caffenet
2、均值文件。
有了caffemodel文件，就需要对应的均值文件，在测试阶段，需要把测试数据减去均值。这个文件我们用脚本来下载，在caffe根目录下执行：
# sudo sh ./data/ilsvrc12/get_ilsvrc_aux.sh
执行并下载后，均值文件放在 data/ilsvrc12/ 文件夹里。
3、synset_words.txt文件
在调用脚本文件下载均值的时候，这个文件也一并下载好了。里面放的是1000个类的名称。
数据准备好了，我们就可以开始分类了，我们给大家提供两个版本的分类方法：
一、c++方法
在caffe根目录下的 examples/cpp-classification/ 文件夹下面，有个classification.cpp文件，就是用来分类的。当然编译后，放在/build/examples/cpp_classification/ 下面
我们就直接运行命令：
# sudo ./build/examples/cpp_classification/classification.bin \
models/bvlc_reference_caffenet/deploy.prototxt \
models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel \
data/ilsvrc12/imagenet_mean.binaryproto \
data/ilsvrc12/synset_words.txt \
examples/images/cat.jpg
命令很长，用了很多的\符号来换行。可以看出，从第二行开始就是参数，每行一个，共需要4个参数
运行成功后，输出top-5结果：
---------- Prediction for examples/images/cat.jpg ----------
0.3134 - "n tabby, tabby cat"
0.2380 - "n tiger cat"
0.1235 - "n Egyptian cat"
0.1003 - "n red fox, Vulpes vulpes"
0.0715 - "n lynx, catamount"
即有0.3134的概率为tabby cat, 有0.2380的概率为tiger cat ......
二、python方法
python接口可以使用jupyter notebook来进行可视化操作，因此推荐使用这种方法。
在这里我就不用可视化了，编写一个py文件，命名为py-classify.py
#coding=utf-8
#加载必要的库
import numpy as npimport sys,os
#设置当前目录
caffe_root = '/home/xxx/caffe/'
sys.path.insert(0, caffe_root + 'python')
import caffe
os.chdir(caffe_root)
net_file=caffe_root + 'models/bvlc_reference_caffenet/deploy.prototxt'
caffe_model=caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'
mean_file=caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy'
net = caffe.Net(net_file,caffe_model,caffe.TEST)
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
transformer.set_transpose('data', (2,0,1))
transformer.set_mean('data', np.load(mean_file).mean(1).mean(1))
transformer.set_raw_scale('data', 255)
transformer.set_channel_swap('data', (2,1,0))
im=caffe.io.load_image(caffe_root+'examples/images/cat.jpg')
net.blobs['data'].data[...] = transformer.preprocess('data',im)
out = net.forward()
imagenet_labels_filename = caffe_root + 'data/ilsvrc12/synset_words.txt'
labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\t')
top_k = net.blobs['prob'].data[0].flatten().argsort()[-1:-6:-1]
for i in np.arange(top_k.size):
print top_k[i], labels[top_k[i]]
执行这个文件，输出：
281 n tabby, tabby cat
282 n tiger cat
285 n Egyptian cat
277 n red fox, Vulpes vulpes
287 n lynx, catamount
&caffe开发团队实际上也编写了一个python版本的分类文件，路径为 python/classify.py
运行这个文件必需两个参数，一个输入图片文件，一个输出结果文件。而且运行必须在python目录下。假设当前目录是caffe根目录，则运行：
# cd python
# sudo python classify.py ../examples/images/cat.jpg result.npy
分类的结果保存为当前目录下的result.npy文件里面，是看不见的。而且这个文件有错误，运行的时候，会提示
Mean shape incompatible with input shape
的错误。因此，要使用这个文件，我们还得进行修改：
1、修改均值计算：
mean = np.load(args.mean_file)
&这一行，在下面加上一行：
mean=mean.mean(1).mean(1)
&则可以解决报错的问题。
2、修改文件，使得结果显示在命令行下：
# Classify.
start = time.time()
predictions = classifier.predict(inputs, not args.center_only)
print("Done in %.2f s." % (time.time() - start))
这个地方，在后面加上几行，如下所示：
# Classify.
start = time.time()
predictions = classifier.predict(inputs, not args.center_only)
print("Done in %.2f s." % (time.time() - start))
imagenet_labels_filename = '../data/ilsvrc12/synset_words.txt'
labels = np.loadtxt(imagenet_labels_filename, str, delimiter='\t')
top_k = predictions.flatten().argsort()[-1:-6:-1]
for i in np.arange(top_k.size):
print top_k[i], labels[top_k[i]]
&就样就可以了。运行不会报错，而且结果会显示在命令行下面。
阅读(...) 评论()caffe分类实现_C/C++教程_动态网站制作指南
caffe分类实现
来源：人气：167
本文介绍采用NVIDIA digits训练的模型对图片数据集进行预测分类，使用caffe训练的模型同样有效，在此主要介绍使用digits训练的模型。
NVIDIA digits 官网
一、环境配置
1、digits环境安装
具体不介绍了，官方有：digits安装
2、caffe环境（可选）
因为digits已将caffe封装，可直接安装NVIDIA的digits，当然有caffe环境的可不看
可按照官方教程安装编译caffe（官方安装说明）
二、python实现
# -*- coding:utf-8 -*-
import numpy as np
import sys,os,caffe
import json
import shutil
#统计分类后的图片数
glassesNum = 0
no_glassesNum = 0
def model_classify(image_path):
如果环境变量里没有配置，可将注释去掉
sys.path.insert(0, caffe_root + 'python')
os.chdir(caffe_root)
net = caffe.Net(net_file,caffe_model,caffe.TEST)
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
transformer.set_transpose('data', (2,0,1))
transformer.set_mean('data', np.load(mean_file).mean(1).mean(1))
transformer.set_raw_scale('data', 255)
transformer.set_channel_swap('data', (2,1,0)) # if using RGB instead of BGR
img = caffe.io.load_image(image_path)
net.blobs['data'].data[...] = transformer.eprocess('data',img)
out = net.forward()
labels = np.loadtxt(labels_file, str, delimiter='\t')
top1 = net.blobs['softmax'].data[0].flatten()
top_k = top1.argsort()[-1:-6:-1]
value = round(top1[top_k[0]]*100,2)
key = str(labels[top_k[0]])
value1 = round(top1[top_k[1]]*100,2)
key1 = str(labels[top_k[1]])
keytemp =work_root+key
keytemp1 =work_root+key1
unknow =work_root+'unknow'
data[key] = value
data[key1] = value1
jsonstr = json.dumps(data)
if not os.path.exists(keytemp):
os.makedirs(keytemp)
if not os.path.exists(keytemp1):
os.makedirs(keytemp1)
if not os.path.exists(unknow):
os.makedirs(unknow)
image_path_target='/'+key+str(value)+'_'+image_path.split('/')[-1]
image_path_target1='/'+key1+str(value1)+'_'+image_path.split('/')[-1]
if value &95.00:
shutil.copy(image_path,keytemp+image_path_target)
global no_glassesNum
no_glassesNum +=1
print "================="+str(no_glassesNum+glassesNum)+'/'+filesum,jsonstr+"========================================"
if value1 & 95.00:
shutil.copy(image_path,keytemp1+image_path_target1)
global glassesNum
glassesNum +=1
print "================="+str(no_glassesNum+glassesNum)+'/'+filesum,jsonstr+"============================================"
shutil.copy(image_path,unknow+image_path_target)
# 转换bp格式图像均值文件为npy格式
def BpToNpy():
#sys.path.insert(0, caffe_root + 'python')
MEAN_PROTO_PATH = 'mean.binaryproto' # 待转换的pb格式图像均值文件路径
MEAN_NPY_PATH = 'mean.npy' # 转换后的numpy格式图像均值文件路径
blob = caffe.proto.caffe_pb2.BlobProto() # 创建protobuf blob
data = open(MEAN_PROTO_PATH, 'rb' ).read() # 读入mean.binaryproto文件内容
blob.ParseFromString(data) # 解析文件内容到blob
array = np.array(caffe.io.blobproto_to_array(blob))# 将blob中的均值转换成numpy格式，array的shape （mean_number，channel, hight, width）
mean_npy = array[0] # 一个array中可以有多组均值存在，故需要通过下标选择其中一组均值
np.save(MEAN_NPY_PATH ,mean_npy)
# 获取模型文件
def getFileName(path):
global net_file,caffe_model,labels_file,mean_file
f_list = os.listdir(path)
# print f_list
for filename in f_list:
# os.path.splitext():分离文件名与扩展名
if os.path.splitext(filename)[1] == '.prototxt':
net_file = work_root+filename
if os.path.splitext(filename)[1] == '.caffemodel':
caffe_model = work_root+filename
if os.path.splitext(filename)[1] == '.txt':
labels_file = work_root+filename
if os.path.splitext(filename)[1] == '.npy':
mean_file = work_root+filename
if __name__ == '__main__':
work_root = os.getcwd()+'/'
f_list = os.listdir(work_root)
for filename in f_list:
if not filename.endswith('npy'):
getFileName(work_root)
#如果环境中没有设置caffe工作路径，设置路径
#caffe_root = '/dataTwo/caffe-ssd'
image_path = raw_input("Input your image path: ")
#判断路径是否存在
if os.path.exists(image_path):
#判断是否为目录路径
if os.path.isdir(image_path):
filesum =str(len(sum([i[2] for i in os.walk(image_path)],[])))
filenames = os.listdir(image_path)
for fn in filenames:
fullfilename = os.path.join(image_path,fn)
model_classify(fullfilename)
#判断是否为列表文件
if os.path.exists(image_path):
imglist = open(image_path)
line = imglist.readline()
while line:
print line,
line = imglist.readline().replace('\n','').replace('\r\n','')
model_classify(line)
imglist.close()
model_classify(image_path)
iamgefile = urllib.urlopen(image_path)
status=iamgefile.code
#判路路径是否为网络路径
if(status==200):
image_data = iamgefile.read()
#获取图片名
image_name = os.path.basename(image_path)
#创建新的图片地址
new_imagepath = filepath+"/"+image_name
with open(new_imagepath, 'wb') as code:
code.write(image_data)
model_classify(new_imagepath)
print "not found the folder!"
这里就不过多介绍了，可参考我的GitHub：wulivicte/caffe_classify
优质网站模板训练我们自己的数据
本篇继续之前的教程，下面我们尝试使用别人定义好的网络，来训练我们自己的网络。
1、准备数据
首先很重要的一点，我们需要准备若干种不同类型的图片进行分类。这里我选择从ImageNet上下载了3个分类的图片（Cat，Dog，Fish）。
图片需要分两批：训练集（train）、测试集（test），一般训练集与测试集的比例大概是5:1以上，此外每个分类的图片也不能太少，我这里每个分类大概选了5000张训练图+1000张测试图。
找好图片以后，需要准备以下文件：
words.txt：分类序号与分类对应关系（注意：要从0开始标注）
train.txt：标明训练图片路径及其对应分类，路径和分类序号直接用空格分隔，最好随机打乱一下图片
/opt/caffe/examples/my_simple_image/data/cat_train/n6.JPEG 0
/opt/caffe/examples/my_simple_image/data/cat_train/n8.JPEG 0
/opt/caffe/examples/my_simple_image/data/fish_train/n1.JPEG 2
/opt/caffe/examples/my_simple_image/data/cat_train/n9.JPEG 0
/opt/caffe/examples/my_simple_image/data/cat_train/n6.JPEG 0
/opt/caffe/examples/my_simple_image/data/cat_train/n43.JPEG 0......
val.txt：标明测试图片路径及其对应分类
/opt/caffe/examples/my_simple_image/data/dog_val/n07.JPEG 1
/opt/caffe/examples/my_simple_image/data/dog_val/n19.JPEG 1
/opt/caffe/examples/my_simple_image/data/cat_val/n60.JPEG 0
/opt/caffe/examples/my_simple_image/data/cat_val/n60.JPEG 0
/opt/caffe/examples/my_simple_image/data/cat_val/n59.JPEG 0......
2、生成lmdb文件
lmdb是caffe使用的一种输入数据格式，相当于我们把图片及其分类重新整合一下，变成一个数据库输给caffe训练。
这里我们使用caffenet的create_imagenet.sh文件修改，主要是重新指定一下路径：
EXAMPLE=examples/my_simple_image/
DATA=examples/my_simple_image/data/
TOOLS=build/tools
TRAIN_DATA_ROOT=/
VAL_DATA_ROOT=/
# 这里我们打开resize，需要把所有图片尺寸统一
RESIZE=true
if $RESIZE; then
RESIZE_HEIGHT=256
RESIZE_WIDTH=256
RESIZE_HEIGHT=0
RESIZE_WIDTH=0
echo "Creating train lmdb..."
GLOG_logtostderr=1 $TOOLS/convert_imageset \
--resize_height=$RESIZE_HEIGHT \
--resize_width=$RESIZE_WIDTH \
--shuffle \
$TRAIN_DATA_ROOT \
$DATA/train.txt \
$EXAMPLE/ilsvrc12_train_lmdb　　#生成的lmdb路径
echo "Creating val lmdb..."
GLOG_logtostderr=1 $TOOLS/convert_imageset \
--resize_height=$RESIZE_HEIGHT \
--resize_width=$RESIZE_WIDTH \
--shuffle \
$VAL_DATA_ROOT \
$DATA/val.txt \
$EXAMPLE/ilsvrc12_val_lmdb
#生成的lmdb路径
echo "Done."
3、生成mean_file
下面我们用lmdb生成mean_file，用于训练（具体做啥用的我还没研究。。。）
这里也是用imagenet例子的脚本：
EXAMPLE=examples/my_simple_image
DATA=examples/my_simple_image
TOOLS=build/tools
$TOOLS/compute_image_mean $EXAMPLE/ilsvrc12_train_lmdb $DATA/imagenet_mean.binaryproto
echo "Done."
4、修改solver、train_val配置文件
这里我们可以选用cifar的网络，也可以用imagenet的网络，不过后者的网络结构更复杂一些，为了学习，我们就用cifar的网络来改。
把cifar的两个配置文件拷过来：
cifar10_quick_solver.prototxtcifar10_quick_train_test.prototxt
首先修改cifar10_quick_train_test.prototxt的路径以及输出层数量（标注出黑体的部分）：
name: "CIFAR10_quick"
name: "cifar"
type: "Data"
top: "data"
top: "label"
phase: TRAIN
transform_param {
mean_file: "examples/my_simple_image/imagenet_mean.binaryproto"
data_param {
source: "examples/my_simple_image/ilsvrc12_train_lmdb"
batch_size: 50
#一次训练的图片数量，一般指定50也够了
backend: LMDB
name: "cifar"
type: "Data"
top: "data"
top: "label"
phase: TEST
transform_param {
mean_file: "examples/my_simple_image/imagenet_mean.binaryproto"
data_param {
source: "examples/my_simple_image/ilsvrc12_val_lmdb"
batch_size: 50
#一次训练的图片数量
backend: LMDB
..........
name: "ip2"
type: "InnerProduct"
bottom: "ip1"
top: "ip2"
..........
inner_product_param {
num_output: 3
#输出层数量，就是你要分类的个数
weight_filler {
type: "gaussian"
bias_filler {
type: "constant"
cifar10_quick_solver.prototxt的修改根据自己的实际需要：
net: "examples/my_simple_image/cifar/cifar10_quick_train_test.prototxt"
#网络文件路径test_iter: 20
#测试执行的迭代次数test_interval: 10
#迭代多少次进行测试
base_lr: 0.001
#迭代速率，这里我们改小了一个数量级，因为数据比较少
momentum: 0.9
weight_decay: 0.004
lr_policy: "fixed"
#采用固定学习速率的模式display: 1
#迭代几次就显示一下信息，这里我为了及时跟踪效果，改成1
max_iter: 4000
#最大迭代次数
snapshot: 1000
#迭代多少次生成一次快照
snapshot_prefix: "examples/my_simple_image/cifar/cifar10_quick"
#快照路径和前缀
solver_mode: CPU
#CPU或者GPU
5、开始训练
运行下面的命令，开始训练（为了方便可以做成脚本）
./build/tools/caffe train --solver=examples/my_simple_image/cifar/cifar10_quick_solver.prototxt
网络的配置和训练其实有一些小技巧。
- 训练过程中，正确率时高时低是很正常的现象，但是总体上是要下降的
- 观察loss值的趋势，如果迭代几次以后一直在增大，最后变成nan，那就是发散了，需要考虑减小训练速率，或者是调整其他参数
- 数据不能太少，如果太少的话很容易发散
阅读(...) 评论()