caffe+python+mnist从图片训练到测试单张图片

原文：https://blog.csdn.net/jingkebiao4847/article/details/53925652

环境：caffe已经装好，GPU训练模式，ubuntu14，

1.从图片格式的数据集开始，下载了mnist图片格式的数据集，下载地址：http://download.csdn.net/download/magicarcher/9529956 

解压以后放在caffe-master/data/Mnist_image中，MNIST是一个手写数字数据库,它有60000个训练样本集和10000个测试样本集。

2.数据准备，转换成lmdb格式

首先是在caffe-master/data/Mnist_image中新建一个create_filelist.sh脚本来生成训练和测试数据的标签文件(就是指定什么图片是什么类别的txt)：

# !/usr/bin/env sh
DATA_TRAIN=../../data/Mnist_image/train #../使得能直接在这个目录运行create_filelist.sh
DATA_TEST=../../data/Mnist_image/test
MY=../../data/Mnist_image

echo "Create train.txt..."
rm -rf $MY/train.txt #删除原有的train.txt,在重复生成train.txt的时候用到
for i in 0 1 2 3 4 5 6 7 8 9
do
find $DATA_TRAIN/$i/ -name *.png | cut -d '/' -f6-7 | sed "s/$/ $i/">>$MY/train.txt #以/为分隔符，截取第6-7段作为图片在train.txt中的名称，后面加上标签0~9中一个
done
echo "Create test.txt..."
rm -rf $MY/test.txt
for i in 0 1 2 3 4 5 6 7 8 9
do
find $DATA_TEST/$i/ -name *.png | cut -d '/' -f6-7 | sed "s/$/ $i/">>$MY/test.txt
done
echo "All done"

解释-f6-7:

比如路径$DATA_TRAIN/$i/ -name *.png  = ../../data/Mnist_image/train/0/0_1.png，f6-7就是被/分隔开的第6段和第7段的内容：0/0_1.png

在此路径caffe-master/data/Mnist_image中运行：

create_filelist.sh

就得到train.txt和test.txt文件：

下面是我的设置

#!/usr/bin/env sh
DATA=data/mnist/
MY=examples/myfile

echo "Create train.txt..."
rm -rf $MY/train.txt
for i in 0 1 2 3 4 5 6 7 8 9
do
find $DATA/train/$i/ -name *.png | cut -d '/' -f4-6 | sed "s/$/ $i/">>$MY/train.txt
done

echo "Create test.txt..."
rm -rf $MY/test.txt
for i in 0 1 2 3 4 5 6 7 8 9
do
find $DATA/test/$i/ -name *.png | cut -d '/' -f4-6 | sed "s/$/ $i/">>$MY/test.txt
done
echo "All done"

执行命令 一定要在data之前的文件夹执行，sudo sh 到createfile.sh

#!/usr/bin/env sh
# Create the imagenet lmdb inputs
# N.B. set the path to the imagenet train + val data dirs
set -e

EXAMPLE=../../examples/Mnist_image        #放得到的lmdb、训练得到的模型的路径
DATA=../../data/Mnist_image               #获取数据的路径，注意我们的mnist数据集中的图片都是单通道的(可以用python命令shape来看图片形状是(20,20),证明是单通道)
TOOLS=../..ild/tools                      #使用caffe的工具进行转换格式的路径

TRAIN_DATA_ROOT=$DATA/train/              #根目录
TEST_DATA_ROOT=$DATA/test/

rm $EXAMPLE/number_train_lmdb -rf
rm  $EXAMPLE/number_test_lmdb -rf

# 这个不用了，数据集中的图像都是20*20
#Set RESIZE=true to resize the images to 256x256. Leave as false if images have
# already been resized using another tool.
RESIZE=true
if $RESIZE; then
  RESIZE_HEIGHT=20
  RESIZE_WIDTH=20
else
  RESIZE_HEIGHT=0
  RESIZE_WIDTH=0
fi

if [ ! -d "$TRAIN_DATA_ROOT" ]; then
  echo "Error: TRAIN_DATA_ROOT is not a path to a directory: $TRAIN_DATA_ROOT"
  echo "Set the TRAIN_DATA_ROOT variable in create_imagenet.sh to the path" \
       "where the ImageNet training data is stored."
  exit 1
fi

if [ ! -d "$TEST_DATA_ROOT" ]; then
  echo "Error: TEST_DATA_ROOT is not a path to a directory: $TEST_DATA_ROOT"
  echo "Set the TEST_DATA_ROOT variable in create_imagenet.sh to the path" \
       "where the ImageNet validation data is stored."
  exit 1
fi

echo "Creating train lmdb..."

GLOG_logtostderr=1 $TOOLS/convert_imageset \   #convert_imageaet的用法
    --resize_height=$RESIZE_HEIGHT \
    --resize_width=$RESIZE_WIDTH \
    --shuffle \
    --gray=true \                               #注意因为训练数据是灰度图，所以这里要令gray=true，默认是false，就会导致训练得到的lmdb是3通道的
    $TRAIN_DATA_ROOT \                          #根目录
    $DATA/train.txt \                           #train.txt的路径
    $EXAMPLE/number_train_lmdb                  #放生成的lmdb的路径

echo "Creating val lmdb..."

GLOG_logtostderr=1 $TOOLS/convert_imageset \
    --resize_height=$RESIZE_HEIGHT \
    --resize_width=$RESIZE_WIDTH \
    --shuffle \
    --gray=true \
    $TEST_DATA_ROOT\
    $DATA/test.txt \
    $EXAMPLE/number_test_lmdb

echo "Done."

然后在caffe-master/examples中新建一个文件夹Mnist_image,在Mnist_image中新建脚本文件create_lmdb.sh:

于是生成如上两个lmdb文件夹。

下面是我的设置

生成lmdb的代码，我调用的caffe里的convert_imageset区裁剪

MY=examples/myfile

echo "Create train lmdb.."
rm -rf $MY/img_train_lmdb
/home/hp/caffe/build/tools/convert_imageset \
--shuffle \
--resize_height=20 \
--resize_width=20 \
/home/hp/mytest/data/mnist/ \
$MY/train.txt \
$MY/img_train_lmdb

echo "Create test lmdb.."
rm -rf $MY/img_test_lmdb
/home/hp/caffe/build/tools/convert_imageset \
--shuffle \
--resize_width=20 \
--resize_height=20 \
/home/hp/mytest/data/mnist/ \
$MY/test.txt \
$MY/img_test_lmdb

echo "All Done.."

然后在mytest路径夏运行sh

3.计算均值并保存

图片减去均值再训练，会提高训练速度和精度。因此，一般都会有这个操作。 
caffe程序提供了一个计算均值的文件compute_image_mean.cpp，我们直接使用就可以了：

sudo build/tools/compute_image_mean examples/Mnist_image/number_train_lmdb examples/Mnist_image/mean.binaryproto

• 1
• 
  

生成均值文件 mean.binaryproto，但是好像默认的生成路径在根目录下。

下面是我的操作

sudo ../caffe/build/tools/compute_image_mean examples/myfile/img_train_lmdb examples/myfile/mean.binaryproto

4.创建模型并修改配置文件

这里为了统一我改了一下

模型就用caffe自带的caffenet模型，位置在 models/bvlc_reference_caffenet/文件夹下, 将需要的两个配置文件，复制到myfile文件夹内

# sudo cp ../caffe/models/bvlc_reference_caffenet/solver.prototxt examples/myfile/
# sudo cp ../caffe/models/bvlc_reference_caffenet/train_val.prototxt examples/myfile/

但是后来发现solver里面配置更改需要匹配，具体可参见我的solver及其配置讲解，这里暂时用下面的设置，后期我在完善其他命令。命令根据自己稍微修改,主要是路径问题

模型就用examples中自带的模型，位置在examples/mnist目录下, 将需要的两个配置文件lenet_solver.prototxt和lenet_train_val.prototxt，复制到examples/Mnist_image/目录下，更名为solver.prototxt和train_val.prototxt，打开solver.prototxt,只需修改两个路径，其他参数不用修改：？？？？？？？？？test？那train呢？

# The train/test net protocol buffer definition
net: "examples/Mnist_image/train_test.prototxt"                            #指定训练模型文件的位置
# test_iter specifies how many forward passes the test should carry out.
# In the case of MNIST, we have test batch size 100 and 100 test iterations,
# covering the full 10,000 testing images.
test_iter: 100
# Carry out testing every 500 training iterations.
test_interval: 500
# The base learning rate, momentum and the weight decay of the network.
base_lr: 0.01
momentum: 0.9
weight_decay: 0.0005
# The learning rate policy
lr_policy: "inv"
gamma: 0.0001
power: 0.75
# Display every 100 iterations
display: 100
# The maximum number of iterations
max_iter: 10000
# snapshot intermediate results
snapshot: 5000
snapshot_prefix: "examples/Mnist_image/caffenet_train"
# solver mode: CPU or GPU
solver_mode: GPU

然后train_val.prototxt也只用修改一下路径，参数什么的都不用改。

根据自己不同路径修改，注意路径名和文件名不要写错。

name: "LeNet"
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "examples/mnist/mnist_train_lmdb"
    batch_size: 64
    backend: LMDB
  }
}
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "examples/mnist/mnist_test_lmdb"
    batch_size: 100
    backend: LMDB
  }
}
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 20
    kernel_size: 5
    stride: 1
    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"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param {
    num_output: 50
    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: "ip1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "ip1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "ip1"
  top: "ip1"
}
layer {
  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: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "accuracy"
  type: "Accuracy"
  bottom: "ip2"
  bottom: "label"
  top: "accuracy"
  include {
    phase: TEST
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "ip2"
  bottom: "label"
  top: "loss"
}

5.训练

同样从位置在examples/mnist目录下, 复制lenet_train.sh到examples/Mnist_image目录,并更名为train.sh，修改路径：

 #!/usr/bin/env sh
set -e

.build/tools/caffe train --solver=examples/Mnist_image/solver.prototxt $@

训练方法修改，用我的方法，调用caffe的可执行文件训练

sudo ../caffe/build/tools/caffe train -solver examples/myfile/solver.prototxt

然后在caffe-master目录运行 examples/Mnist_image/train_lenet.sh ，就会开始训练得到caffenet_train_iter_10000.caffemodel。整个训练过程就完了，最后就是为了得到这个caffemodel模型。下面尝试对任意一张图片使用这个caffemodel进行测试，看是否准确。

6.使用deploy.py生成deploy.prototxt

在examples/Mnist_image目录下新建deploy.py：

设置不同，命令不同，下面是我的层序

# -*- coding: utf-8 -*-
caffe_root = '/home/hp/mytest/examples/myfile/'    
import sys    
sys.path.insert(0, caffe_root + 'python')    
from caffe  import layers as L,params as P,to_proto  
root='/home/hp/mytest/examples/myfile/'  
deploy='/home/hp/mytest/examples/myfile/deploy.prototxt'    #文件保存路径  
      
def create_deploy():  
        #少了第一层，data层  
        conv1=L.Convolution(name='conv1',bottom='data', kernel_size=5, stride=1,num_output=20, pad=0,weight_filler=dict(type='xavier'))  
        pool1=L.Pooling(conv1,name='pool1',pool=P.Pooling.MAX, kernel_size=2, stride=2)  
        conv2=L.Convolution(pool1, name='conv2',kernel_size=5, stride=1,num_output=50, pad=0,weight_filler=dict(type='xavier'))  
        pool2=L.Pooling(conv2, name='pool2',top='pool2', pool=P.Pooling.MAX, kernel_size=2, stride=2)  
        fc3=L.InnerProduct(pool2, name='ip1',num_output=500,weight_filler=dict(type='xavier'))  
        relu3=L.ReLU(fc3, name='relu1',in_place=True)  
        fc4 = L.InnerProduct(relu3, name='ip2',num_output=10,weight_filler=dict(type='xavier'))  
        #最后没有accuracy层，但有一个Softmax层  
        prob=L.Softmax(fc4, name='prob')  
        return to_proto(prob)  
def write_deploy():   
        with open(deploy, 'w') as f:  
            f.write('name:"LeNet"\n')  
            f.write('layer {\n')  
            f.write('name:"data"\n')  
            f.write('type:"Input"\n')  
            f.write('input_param { shape : {')  
            f.write('dim:1 ')  
            f.write('dim:3 ')  
            f.write('dim:28 ')  
            f.write('dim:28 ')  
            f.write('} }\n\n')  
            f.write(str(create_deploy()))  
if __name__ == '__main__':  
        write_deploy() 

注意python一定要对其阿，缩进，不然报错

# -*- coding: utf-8 -*-
caffe_root = '/home/cvlab01/2016liulu/caffe-master/'
import sys
sys.path.insert(0, caffe_root + 'python')
from caffe  import layers as L,params as P,to_proto
root='/home/cvlab01/2016liulu/caffe-master/'
deploy='/home/cvlab01/2016liulu/caffe-master/examples/Mnist_image/deploy.prototxt'    #文件保存路径

def create_deploy():
    #少了第一层，data层
    conv1=L.Convolution(name='conv1',bottom='data', kernel_size=5, stride=1,num_output=20, pad=0,weight_filler=dict(type='xavier'))
    pool1=L.Pooling(conv1,name='pool1',pool=P.Pooling.MAX, kernel_size=2, stride=2)
    conv2=L.Convolution(pool1, name='conv2',kernel_size=5, stride=1,num_output=50, pad=0,weight_filler=dict(type='xavier'))
    pool2=L.Pooling(conv2, name='pool2',top='pool2', pool=P.Pooling.MAX, kernel_size=2, stride=2)
    fc3=L.InnerProduct(pool2, name='ip1',num_output=500,weight_filler=dict(type='xavier'))
    relu3=L.ReLU(fc3, name='relu1',in_place=True)
    fc4 = L.InnerProduct(relu3, name='ip2',num_output=10,weight_filler=dict(type='xavier'))
    #最后没有accuracy层，但有一个Softmax层
    prob=L.Softmax(fc4, name='prob')
    return to_proto(prob)
def write_deploy():
    with open(deploy, 'w') as f:
        f.write('name:"LeNet"\n')
        f.write('layer {\n')
        f.write('name:"data"\n')
        f.write('type:"Input"\n')
        f.write('input_param { shape : {')
        f.write('dim:1 ')
        f.write('dim:3 ')
        f.write('dim:28 ')
        f.write('dim:28 ')
        f.write('} }\n\n')
        f.write(str(create_deploy()))
if __name__ == '__main__':
    write_deploy()

运行deploy.py生成的deploy.prototxt如下：

name: "LeNet"
layer {
  name: "data"
  type: "Input"
  top: "data"
  input_param { shape: { dim: 1 dim: 1 dim: 20 dim: 20 } }#灰度图像，dim为1，不能弄错了
}
#/*卷积层与全连接层中的权值学习率，偏移值学习率，偏移值初始化方式,因为这些值在caffemodel文件中已经提供*/
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  convolution_param {
    num_output: 20
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
  }
}
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
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer {
  name: "ip1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "ip1"
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "ip1"
  top: "ip1"
}
layer {
  name: "ip2"
  type: "InnerProduct"
  bottom: "ip1"
  top: "ip2"
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
  }
}

#/*删除了原有的测试模块的测试精度层*/

#/*输出层的类型由SoftmaxWithLoss变成Softmax，训练是输出时是loss，应用时是prob。*/
layer {
  name: "prob"
  type: "Softmax"
  bottom: "ip2"
  top: "prob"
}

7.准备均值文件 meanfile.npy和synset_words.txt

因为classify.py中的测试接口caffe.Classifier需要训练图片的均值文件作为输入参数，而实际lenet-5训练时并未计算均值文件，所以这里创建一个全0的均值文件输入。编写一个zeronp.py文件如下 

执行

python zeronp.py

• 1

• 1

生成均值文件 meanfile.npy。 

在examples/Mnist_image中新建synset_words.txt：

0 zero
1 one
2 two
3 three
4 four
5 five
6 six
7 seven
8 eight
9 nine

8. 修改classify.py保存为classifymnist.py文件

在目录caffe-master/python中有classify.py文件，复制一份并改名为classifymnist.py然后进行如下修改：

#!/usr/bin/env python
#coding:utf-8
"""
classify.py is an out-of-the-box image classifer callable from the command line.

By default it configures and runs the Caffe reference ImageNet model.
"""
caffe_root = '/home/cvlab01/2016liulu/caffe-master/'
import sys
sys.path.insert(0, caffe_root + 'python')

import numpy as np
import os
import sys
import argparse
import glob
import time
import pandas as pd #插入数据分析包

import caffe


def main(argv):
    pycaffe_dir = os.path.dirname(__file__)

    parser = argparse.ArgumentParser()
    # Required arguments: input and output files.
    parser.add_argument(
        "input_file",
        help="Input image, directory, or npy."
    )
    parser.add_argument(
        "output_file",
        help="Output npy filename."
    )
    # Optional arguments.
    parser.add_argument(
        "--model_def",
        default=os.path.join(pycaffe_dir,
                "../examples/Mnist_image/deploy.prototxt"), #指定deploy.prototxt的模型位置
        help="Model definition file."
    )
    parser.add_argument(
        "--pretrained_model",
        default=os.path.join(pycaffe_dir,
                "../examples/Mnist_image/caffenet_train_iter_10000.caffemodel"), #指定caffemodel模型位置，这就是我们前面自己训练得到的模型
        help="Trained model weights file."
    )
    #######新增^^^^^^^^^start^^^^^^^^^^^^^^^^^^^^^^
    parser.add_argument(
        "--labels_file",
        default=os.path.join(pycaffe_dir,
                "../examples/Mnist_image/synset_words.txt"), #指定输出结果对应的类别名文件???????????????????????????
        help="mnist result words file"
    )
    parser.add_argument(
        "--force_grayscale",
        action='store_true',   #增加一个变量将输入图像强制转化为灰度图，因为lenet-5训练用的就是灰度图
        help="Converts RGB images down to single-channel grayscale versions," +
                   "useful for single-channel networks like MNIST."
    )
    parser.add_argument(
        "--print_results",
        action='store_true', #输入参数要求打印输出结果
        help="Write output text to stdout rather than serializing to a file."
    )
    #######新增^^^^^^^^^end^^^^^^^^^^^^^^^^^^^^^^
    parser.add_argument(
        "--gpu",
        action='store_true',
        help="Switch for gpu computation."
    )
    parser.add_argument(
        "--center_only",
        action='store_true',
        help="Switch for prediction from center crop alone instead of " +
             "averaging predictions across crops (default)."
    )
    parser.add_argument(
        "--images_dim",
        default='20,20', #指定图像寬高
        help="Canonical 'height,width' dimensions of input images."
    )
    parser.add_argument(
        "--mean_file",
        default=os.path.join(pycaffe_dir,
                             '../examples/Mnist_image/meanfile.npy'), #指定均值文件
        help="Data set image mean of [Channels x Height x Width] dimensions " +
             "(numpy array). Set to '' for no mean subtraction."
    )
    parser.add_argument(
        "--input_scale",
        type=float,
        help="Multiply input features by this scale to finish preprocessing."
    )
    parser.add_argument(
        "--raw_scale",
        type=float,
        default=255.0,
        help="Multiply raw input by this scale before preprocessing."
    )
    parser.add_argument(
        "--channel_swap",
        default='2,1,0',
        help="Order to permute input channels. The default converts " +
             "RGB -> BGR since BGR is the Caffe default by way of OpenCV."
    )
    parser.add_argument(
        "--ext",
        default='jpg',
        help="Image file extension to take as input when a directory " +
             "is given as the input file."
    )
    args = parser.parse_args()

    image_dims = [int(s) for s in args.images_dim.split(',')]

    mean, channel_swap = None, None
    if args.mean_file:
        mean = np.load(args.mean_file).mean(1).mean(1)
    if args.channel_swap:
        channel_swap = [int(s) for s in args.channel_swap.split(',')]

    if args.gpu:
        caffe.set_mode_gpu()
        print("GPU mode")
    else:
        caffe.set_mode_cpu()
        print("CPU mode")

    # Make classifier.
    classifier = caffe.Classifier(args.model_def, args.pretrained_model,
            image_dims=image_dims, mean=mean,
            input_scale=args.input_scale, raw_scale=args.raw_scale,
            channel_swap=None)

    # Load numpy array (.npy), directory glob (*.jpg), or image file.
    args.input_file = os.path.expanduser(args.input_file)
    if args.input_file.endswith('npy'):
        print("Loading file: %s" % args.input_file)
        inputs = np.load(args.input_file)
    elif os.path.isdir(args.input_file):
        print("Loading folder: %s" % args.input_file)
        inputs =[caffe.io.load_image(im_f)
                 for im_f in glob.glob(args.input_file + '/*.' + args.ext)]
    else:
        print("Loading file: %s" % args.input_file)
        inputs = [caffe.io.load_image(args.input_file,not args.force_grayscale)] #强制图片为灰度图

    print("Classifying %d inputs." % len(inputs))

    # Classify.
    start = time.time()
    scores = classifier.predict(inputs, not args.center_only).flatten()
    print("Done in %.2f s." % (time.time() - start))

    #增加输出结果打印到终端^^^start^^^^^
    # print
    if args.print_results:
        with open(args.labels_file) as f:
            labels_df = pd.DataFrame([{'synset_id':l.strip().split(' ')[0], 'name': ' '.join(l.strip().split(' ')[1:]).split(',')[0]} for l in f.readlines()])
            labels = labels_df.sort('synset_id')['name'].values

            indices =(-scores).argsort()[:5]
            predictions = labels[indices]
            print predictions
            print scores

            meta = [(p, '%.5f' % scores[i]) for i,p in zip(indices, predictions)]
            print meta
    #增加输出结果打印到终端vvvvendvvvvvvv


    # Save
    print("Saving results into %s" % args.output_file)
    np.save(args.output_file, predictions)


if __name__ == '__main__':
    main(sys.argv)

8.测试，在classifymnist.py目录下准备一个灰度图像3.jpg，大小和mnist中一样，然后执行：

python classifymnist.py --print_results --force_grayscale --center_only --labels_file ../examples/Mnist_image/synset_words.txt ../examples/Mnist_image/3.jpg resultsfile

借鉴了http://blog.csdn.net/lanxuecc/article/details/52485077的博主一系列的文章，表示感谢，这里只是自己记录学习过程，如果侵权，很抱歉

• 
  fafds23 2018-03-01 17:41:44 #2楼

  mnist数据集不是28*28的图片吗，怎么变成20*20了

• 
  归去-也无风雨也无晴 2017-08-02 16:58:40 #1楼

  非常好，感谢！

• 上一页
• 1
• 下一页

caffe笔记3——用python实现mnist

官网教程：http://nbviewer.jupyter.org/github/BVLC/caffe/blob/master/examples/01-learning-lenet.ipynb１. 改变...

qq_30159351

2016-12-16 14:00:00

阅读数：926

初识caffe之python mnist训练

1、下载数据caffe源码中提供了下载mnist数据的脚本get_mnist.sh，但是因为是windows环境下，脚本无法运行，只能手动下载。进入caffe_root\data\mnist目录，...

yunken28

2017-01-11 16:24:26

阅读数：992

手把手教你用python写脚本看caffe训练好的网络测试单张..._CSDN博客

(选最后一个)文件,还有一个图像均值文件,然后再需要一张图片,用caffe的python接口,编写简单脚本,就可以用这几个文件构建训练好的网络,来测试特定的单张图片,然后...

2018-5-3

caffe测试单张图片 - CSDN博客

利用编译caffe工程生成的classification.exe可完成对一张图片的预测。... lishanlu136 2017年04月16日 22:00 1162 caffe+python+mnist从图片训练到测试单张图片 ...

2018-4-17

27岁银川妹子竟悟出股市投资铁律，爆赚成网红 瓦普 · 顶新

Caffe+Python接口测试MNIST--下载和准备数据

caffe-python接口-mnist 的测试

xihuaxi

2017-03-16 19:40:18

阅读数：705

手把手教你用python写脚本看caffe训练好的网络测试单张图片的输出

因为参加比赛的缘故,要在linux下用caffe对数据集中的人脸进行分类训练,训练一个网络,然后主办方在后期放出测试集之后,我用训练好的网络对测试集里面的图片进行测试分...

2017-7-8

手把手教你用python写脚本看caffe训练好的网络测试单张图片的输出

手把手教你用python写脚本看caffe训练好的网络测试单张图片的输出  (729)  (3)  举报  收藏     因为参加比赛的缘故,要在linux下用...

2018-5-3

mnist训练与测试自己手写数字

一、训练 1、从http://yann.lecun.com/exdb/mnist/下载的数据集 这需要进行数据结构转化，转化为lmdb格式。 解压到caffe->data->mnist文件夹...

swj110119

2016-12-01 17:23:52

阅读数：10060

用caffe训练好的lenet_iter_10000.caffemodel测试单张mnist图片

接上个博客：http://blog.csdn.net/lanxuecc/article/details/52474476，前面已经生成了deploy.proto.txt。下面具体记录用lenet_it...

lanxueCC

2016-09-09 14:05:09

阅读数：11917

caffe+python 使用训练好的VGG16模型 对 单张图片进行..._CSDN博客

网上看了一堆都是图片转lmdb格式,然后测试总的准确率,我想测试每张图片的top1...caffe+python 使用训练好的VGG16模型 对 单张图片进行分类,输出置信度 (14285) ...

2018-4-20

caffe+python+mnist从图片训练到测试单张图片 - CSDN博客

caffe+python+mnist从图片训练到测试单张图片 阅读量:202 刚刚开通博客 阅读量...解压以后放在caffe-master/data/Mnist_image中,MNIST是一个手写数字数据库,它有...

2018-5-7

caffe mnist实战训练（5）用可视化图片解决问题

前面记录了生成lmdb文件和模型，模型的准确率也达到了0.98，现在开始用一张实际的图片来实验先编写一个deploy.protoxtx文件，代码如下name: "AlexNet"layer {...

hjxu2016

2017-04-06 16:02:39

阅读数：407

27岁银川妹子竟悟出股市投资铁律，爆赚成网红 铭彪 · 顶新

Caffe深度学习入门——python调用caffe训练好的模型检..._CSDN博客

python直接调用caffe训练好的模型,进行单帧图片检测,并显示检测结果。caffe自带的...到了foo文件,不能直观显示,这里加入几行显示的代码,方便直接测试查看结果,运行...

2018-3-21

caffe学习(6)---单张图像测试 - CSDN博客

利用编译caffe工程生成的classification.exe可完成对一张图片的预测。其参数调用格式...caffe+python+mnist从图片训练到测试单张图片 环境:caffe已经装好,GPU训练模式,ub...

2018-4-16

用caffe训练测试自己的图片

所有的操作是基于caffe的根目录/caffe-master/来操作的：数据准备我所用的图片是车牌识别中，0～9数字图片，在data下面新建一个number目录，用来存放训练图片（caffenumim...

lanxueCC

2016-08-26 16:28:38

阅读数：7970

使用自己的图片测试MNIST训练效果（TensorFlow1.5+CNN）

作为初学者研究了两周的TensorFlow基础的东西。首先是MNIST数据集在CNN的训练。中间经历了很多问题。现在TensorFlow的版本已经更新到1.5，出了很多高级API，所以很多博客都不再合...

zym_1990

2018-02-09 15:02:28

阅读数：409

使用caffe的python接口预测多张图片 - CSDN博客

         使用classification.bin只能预测单张图片,或者使用...的模型(caffemodel)来分类新的图片 caffemodel进行批量测试环境:win7,python2.7....

2018-4-17

undefined

mnist测试自己手写数字

转载：http://blog.csdn.net/u013407923/article/details/53084984在之前的实验中我们使用过 $ ./build/tools/caffe.bi...

qq_34637408

2017-01-09 15:46:29

阅读数：187

手把手教你用python写脚本看caffe训练好的网络测试单张图片的输出

因为参加比赛的缘故，要在linux下用caffe对数据集中的人脸进行分类训练，训练一个网络，然后主办方在后期放出测试集之后，我用训练好的网络对测试集里面的图片进行测试分类。    根据我博客风格...

qq_30372847

2016-07-02 21:47:15

阅读数：6623

ubuntu下caffe实战---mnist数据集测试

测试用到手写体识别模型LeNet，mnist数据集其中LeNet是一种CNN模型，由一个卷积层、后面跟一个下采样层、再跟另外一个卷积层和另一个下采样层，再之后是两个全连接层组成。mnist...

wzx9511

2017-04-17 18:37:49

阅读数：1726

Caffe编译 Mnist训练测试

Caffe编译进入目录/caffe-master/，输入下列命令编译整个caffe工程make cleanmake all 补充说明：很多添加编译选项，据说是为利用cpu的4个核并行编译加快编译效率...

lanxueCC

2016-07-29 14:43:59

阅读数：7907

ubuntu16.04+caffe训练mnist数据集

1.   caffe-master文件夹权限修改下载的caffe源码编译的caffe-master文件夹貌似没有写入权限，输入以下命令修改：sudo chmod -R 777 ~/caffe-...

dcrmg

2017-07-16 20:05:34

阅读数：901

Ubuntu安装Caffe并训练MNIST

之前的博客，我们介绍了如何在Mac下安装Caffe并训练MNIST，但是在Mac下有很多不方便的地方，今天介绍一下如何在Ubuntu下安装Caffe并且训练MNIST。...

lkj345

2016-04-29 14:15:09

阅读数：7411

caffe测试单张图片

所有的操作是基于caffe的根目录/caffe-master/来操作的：1、caffe提供了一个用已经训练好的caffemodel来分类单张图片的库(./build/examples/cpp_clas...

lanxueCC

2016-10-12 11:05:28

阅读数：5475

python读取caffemodel文件

caffemodel是二进制的protobuf文件，利用protobuf的python接口可以读取它，解析出需要的内容不少算法都是用预训练模型在自己数据上微调，即加载“caffemodel”作为网络...

haoji007

2017-08-10 08:54:10

阅读数：776

caffe+python 使用训练好的VGG16模型 对 单张图片进行分类，输出置信度

原文：http://blog.csdn.net/tangwenbo124/article/details/52725263网上看了一堆都是图片转lmdb格式，然后测试总的准...

wonengguwozai

2016-12-06 11:38:33

阅读数：1848

caffe预测单张图片

https://github.com/BVLC/caffe/issues/2304 https://github.com/BVLC/caffe/issues/566../build/tools/ca...

fk1174

2017-11-20 15:46:46

阅读数：179

Caffe傻瓜系列(9)：训练和测试自己的图片

在深度学习的实际应用中，我们经常用到的原始数据是图片文件，如jpg,jpeg,png,tif等格式的，而且有可能图片的大小还不一致。而在caffe中经常使用的数据类型是lmdb或leveldb，因此就...

langb2014

2016-01-04 21:25:45

阅读数：10242

Ubuntu14.04+caffe实现cifar10例程及单张图片测试

一.环境Ubuntu14.04+caffe(无GPU）二.训练模型    下载数据：cd caffe(caffe根目录）                      ./data/cifar...

Tramac

2016-11-02 15:35:45

阅读数：2512

• 
  

• 
  评论
• 
  微信
• 
  微博
• 
  QQ

关闭