caffe应用-01灰度图像分类之手写体数字识别

最新推荐文章于 2024-04-25 11:31:48 发布
最新推荐文章于 2024-04-25 11:31:48 发布
阅读量1.8k 收藏 6
点赞数 1
文章标签： caffe 手写数字识别 手写识别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Terrenceyuu/article/details/76623801
版权

caffe应用-01灰度图像分类之手写体数字识别

  • 很多情况下，我们去做图像的分类可能和图像的颜色没有太大的关系，像手写体识别，人脸识别等。
  • mnist的这个例子是caffe官方自带的，他的数据源包括60000张的训练数据以及10000张的测试数据。其中，每张都是大小为28*28像素的单通道（灰度值为0-255）图片。

1.制作lmdb数据源

  • 将所需图片文件夹（tain和test）下载后放在一个文件夹里。此时，我们需要编写一个简单的python程序用来生成一个txt文件来描述这些图片的信息（包括其文件路径和label）
  • 这个python文件命名为createFileList.py，其内容如下：
#ecoding:utf_8
import os

folderName = '/home/terrence/caffe_case/mnist/'


for i in range(10):
    #列出文件夹所有文件
    dirList = os.listdir(folderName + 'train/' + str(i) + '/')

    f = open(folderName+'train.txt', 'a+');
    for name in dirList:
        print name
        f.write(str(i) + '/' + name + ' '+ str(i) +'\n')    
f.close()

for i in range(10):
    #列出文件夹所有文件
    dirList = os.listdir(folderName + 'test/' + str(i) + '/')

    f = open(folderName+'test.txt', 'a+');
    for name in dirList:
        print name
        f.write(str(i) + '/' + name + ' '+ str(i) +'\n')    
f.close()
  • 运行这个程序，得到train.txt和test.txt。其格式如下图所示：
    这里写图片描述
  • 显而易见，其格式为 文件夹+文件名+label
  • 接下来，我们需要一个脚本来制作lmdb数据源了，这个脚本命名为create_lmdb.sh，内容如下：
#!/usr/bin/env sh 
# Create the imagenet lmdb inputs
# N.B. set the path to the imagenet train + val data dirs
# ~/caffe/examples/imagenet/create_imagenet.sh
set -e

EXAMPLE=/home/terrence/caffe_case/mnist 
DATA=/home/terrence/caffe_case/mnist 
TOOLS=/home/terrence/caffe/build/tools

TRAIN_DATA_ROOT=/home/terrence/caffe_case/mnist/train/
VAL_DATA_ROOT=/home/terrence/caffe_case/mnist/test/ 

# Set RESIZE=true to resize the images to 256x256. Leave as false if images have
# already been resized using another tool.
RESIZE=false
if $RESIZE; then
  RESIZE_HEIGHT=28
  RESIZE_WIDTH=28
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 "$VAL_DATA_ROOT" ]; then
  echo "Error: VAL_DATA_ROOT is not a path to a directory: $VAL_DATA_ROOT"
  echo "Set the VAL_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 \
    --resize_height=$RESIZE_HEIGHT \
    --resize_width=$RESIZE_WIDTH \
    --shuffle \
    --gray=true \
    $TRAIN_DATA_ROOT \
    $DATA/train.txt \
    $EXAMPLE/img_train_lmdb

echo "Creating val lmdb..."

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

echo "Done."

  • 除了路径要修改之外，我们还需要加上–gray=true \一个参数，目的是代表将图像当做灰度图像来处理。此外，由于我们源数据的图像大小都是一样的（28*28），所以就不需要resize了，因此设置RESIZE=false。

  • 运行这个脚本，就可以生成这两个文件夹：img_test_lmdb和img_train_lmdb。至此，lmdb数据源制作完毕。

2.训练数据

  • 训练数据的命令保存在train_lenet.sh这个脚本里了，内容如下：
#!/usr/bin/env sh
set -e

/home/terrence/caffe/build/tools/caffe train --solver=/home/terrence/caffe_case/mnist/lenet_solver.prototxt $@
# The train/test net protocol buffer definition
net: "/home/terrence/caffe_case/mnist/lenet_train_test.prototxt" #lenet_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: "/home/terrence/caffe_case/mnist/model/lenet" #caffemodel
# solver mode: CPU or GPU
solver_mode: GPU

name: "LeNet"
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "/home/terrence/caffe_case/mnist/img_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: "/home/terrence/caffe_case/mnist/img_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"
}

  • 这个文件需要制定文件路径的修改即可。

  • 这几个文件都创建完成后，我们就可以运行train_lenet.sh这个脚本了，运行完成会在model文件夹下生成迭代5000以及10000次的最终模型结构的描述文件，其中的以.caffemodel结尾的文件在我们测试的时候会用到。

2-1 训练数据的减均值操作

  • 讲到这里我们以及训练完了数据，可是还没有做减均值的操作，在这个应用里因为没有做也可以达到一个很好的效果，所以就不打算做了。
  • 接下来，会讲到如何做减均值这一步的操作。
  • 首先，我们要创建一个mean.sh的脚本：
sudo /home/terrence/caffe/build/tools/compute_image_mean ./img_train_lmdb ./mean.binaryproto

  • 它就是将img_train_lmdb这个训练的lmdb数据源减均值并存放在mean.binaryproto文件下。运行脚本就可以得到此文件了。

  • 使用这个文件也很简单，我们需要在lenet_train_test.prototxt文件中的数据层指定这个文件的位置：
    这里写图片描述

3. 利用训练好的模型测试图片

  • 测试某一张图片需要以下指令：

    python classify.py --print_results --force_grayscale --center_only --labels_file ./synset_words.txt ./02972.png resultsfile

  • 其中，02972.png是一张手写体数字图片：

这里写图片描述

  • 然后是synset_words.txt文件，描述网络输出的10个数字代表的含义：
0 zero
1 one
2 two
3 three
4 four
5 five
6 six
7 seven 
8 eight
9 nine

最后是一个classify.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/terrence/caffe/'    
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,  
            "./deploy.prototxt"), #指定deploy.prototxt的模型位置  
    help="Model definition file."  
)  
parser.add_argument(  
    "--pretrained_model",  
    default=os.path.join(pycaffe_dir,  
            "./model/lenet_iter_10000.caffemodel"), #指定caffemodel模型位置，这就是我们前面自己训练得到的模型  
    help="Trained model weights file."  
)  
#######新增^^^^^^^^^start^^^^^^^^^^^^^^^^^^^^^^  
parser.add_argument(  
    "--labels_file",  
    default=os.path.join(pycaffe_dir,  
            "./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='28,28', #指定图像寬高  
    help="Canonical 'height,width' dimensions of input images."  
)  
parser.add_argument(  
    "--mean_file",  
    default=os.path.join(pycaffe_dir,  
                         './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)

  • 这里需要注意的就是指定一个mean_file文件，这是均值文件，因为我们在lenet_train_test.prototxt并没有做减均值的操作，所以生成一个值为0大小是（28*28*1）的数组即可，注意是[Channels x Height x Width]

  • 生成数组的python代码如下：

    import numpy as np
zeros = np.zeros((1,28,28), dtype=np.float32)
np.save('meanfile.npy', zeros)

4. 测试结果

这里写图片描述

跬步千里OvO
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写数字数据集（图像28*28）
10-09
手写数字图片，一共5000张，像素28*28，数字0-9，每个各500张； 可用于神经网络的图像分类的样本等，
深度学习（3）手写数字识别问题
weixin_43360025的博客
08-07 1523
深度学习（3）手写数字识别问题1. 问题归类2. 数据集3. Image4. Input and Output5. Regression VS Classification6. Computation Graph7. 两个问题8. Particularly9. 如何训练模型？→\to→ Loss10. 总结11. Deep Learning?12. Classification Procedure13. We need TensorFlow14. Next 1. 问题归类 Discrete Predicti
利用caffe68点检测人脸特征点，识别疲劳状态，眼睛缝隙小为判断依据，支持Python和C++
最新发布
pQpctjNOx的博客
04-25 318
本文针对疲劳识别问题，设计了一套基于caffe68点检测人脸特征点的算法。若缝隙小于一定阈值，则认为人体处于疲劳状态。caffe68点检测人脸特征点是一种基于卷积神经网络的方法，通过学习大量带有标注的人脸特征点数据集，该网络能够准确地定位面部区域的关键特征点，包括眼睛、鼻子、嘴巴等部位。针对疲劳的准确识别和预警，研究人员提出了基于人脸特征点检测的方法，其中caffe68点检测人脸特征点是一种常用的技术。采用caffe68点检测人脸特征点，识别疲劳，当眼睛缝隙小，则认为是疲劳，有python,c++版本。
手写数字识别（识别纸上手写的数字）
Qyun_lucky_star的博客
08-11 2万+
手写数字识别（识别纸上手写的数字） 使用pytorch框架，实现对MNIST手写数字数据集的训练和识别。重点是，自己手写数字，手机拍照后传入电脑，使用你自己训练的权重和偏置能够识别。数据预处理过程的代码是重点。 分析 要识别自己用手在纸上写的数字，从特征上来看，手写数字相比于普通的电脑上的数字最大的 不同就是数字的边缘会发生不同幅度的抖动。而且，在MNIST数据集中的数字是边缘为黑色的，然后数字是不同灰度的白色的，如下所示： 在数据集中，每个数据都是28∗2828*2828∗28的灰度图，并且黑色部分都是
Python-黑白照片灰度值识别
qq_52137561的博客
09-21 273
Python-黑白照片灰度值识别，点击图片中的任意位置，即可显示该部分灰度值和坐标。
灰度图像形状的识别分类算法实现matlab
热门推荐
u014080185的博客
07-22 4万+
摘  要： 针对已经给出的图像，在分类之前，因为存在噪声和光照的不同，所以要先进行图像增强，并统一将图像转为二值图像。对图像进行边缘检测，可以很容易算出各个图像面积与周长二次方的比值关系，对图像进行直线检测， 可以获得图像中直线的特征，结合图像的以上两种特种对形状进行分类。     算法设计和推导：        1. 图像预处理部分，通过 9X9 均值滤波器，先对图像进行去噪，然后
opencv-dnn使用Caffe训练的model进行手写数字识别
04-12
在本文中，我们将深入探讨如何使用OpenCV的DNN模块结合Caffe框架来实现手写数字的识别。首先，我们要了解Caffe是一个流行的深度学习框架，特别适合于卷积神经网络（CNN）的训练和推理。而OpenCV的DNN模块则提供了与...
手写数字识别10000次cnn结果 (.caffemodel)
11-30
手写数字识别10000次cnn结果，后缀名称为.caffemodel的网络模型文件，已经在caffe初探3中生成了若干网络模型文件，在这里我们可以选择迭代10000次的模型文件，里面包含了网络参数。
用于图像分类的 ResNet-50 模型架构及权重文件(使用 Caffe 框架进行预训练)
09-30
在本资源中，提供的是用 Caffe 框架预训练的 ResNet-50 模型，这使得开发者能够快速地应用此模型到自己的图像分类任务中。 1. **ResNet 架构**： ResNet 的核心创新是引入了残差块（Residual Block）。这种结构...
用python，caffe框架下的，图像目标识别分类适合caffe初学者
11-24
python 程序的图像目标识别与分类程序。用python，caffe框架下的，图像目标识别分类适合caffe初学者
ios-caffe-ObjectRecognition:对象识别演示应用
05-20
ios-caffe-ObjectRecognition 对象识别演示应用 在主文件夹下克隆 ：aleph7 / caffe.git @ 4560c2dcfff5b778c8f1177b8b541427239b3380。（caffe的文件夹名称应为“ caffe”） 将xcode项目与opencv2.framework ...
Python - OpenCV 图像灰度识别
小小晓晓阳的博客
11-08 4819
本片文章将介绍一下基于opencv的图像灰度识别，主要介绍三通道的彩色图片的灰度识别，单通道图片无需判断。 对图片进行灰度识别我们要先明白一个基础知识，理论上讲，一张真正的灰度图应该是单通道或者RGB三通道值相等的，因此我们可以根据通道数或者像素RGB三通道值差异来判断。 接下来我们来介绍两种计算灰度值的方法。 方法一 def calculate_gray_value(img): # 分割RGB通道 r, g, b = cv2.split(img) ...
halcon颜色识别的两种简单方式
weixin_44490080的博客
05-14 1万+
颜色识别的两种简单方式： 1、单通道方式： 原理：通过不同颜色在灰度图中的阈值范围不同来区分颜色（理论上这种方式不推荐，但在一定情况下适用） 材料： halcon代码： dev_close_window () dev_open_window (0, 0, 800, 600, 'black', WH) read_image (Image, 'C:/User...
Halcon基于灰度的颜色识别
whb78952的博客
06-26 2050
程序流程如下： 如下图所示，首先读入图像，将彩色图像转为灰度图像，进行阈值分割，利用connection算子将每个区域分离开，再求取中心点坐标，将颜色名称显示在图像上。 识别结果： Halcon代码如下：...
MINST手写数字转换成28*28图像
weixin_44893109的博客
01-05 1570
先把资源下载后，解压缩； 在当前文件夹中创建data文件夹后，在data文件夹内创建0-9，共十个文件夹； import os import struct import numpy as np import matplotlib.pyplot as plt from PIL import Image def load_mnist(path, kind='train'): """Load MNIST data from `path`""" labels_path = os.path.joi
机器学习 day01(四)
沉觞的博客
07-06 388
手写体数字识别 与ipynb文件夹同级的data文件夹下有10个文件, 每个文件中都是手写体数字的图片 1. 导入绘图模块,查看图片 先读取一张图片,图片为28x28像素 2. 读取文件所有的手写体数字图片 这是一个三维数组,总共有5000张图片 3. 模型训练 3.1 sklearn的算法只接受二维以下的数组 所以不能直接训练 3.2 使用reshape()函数将数组由三维变成二维 d...
手写数字识别 ----在已经训练好的数据上根据28*28的图片获取识别概率（基于Tensorflow,Python）...
weixin_30737363的博客
12-28 2031
通过： 手写数字识别 ----卷积神经网络模型官方案例详解（基于Tensorflow,Python） 手写数字识别 ----Softmax回归模型官方案例详解（基于Tensorflow,Python） 运行程序后得的四个文件，再通过手写的图片判断识别概率 代码： import numpy as np import tensorflow as tf from flask i...
深度学习（手写数字识别）
weixin_65089713的博客
03-31 1万+
目录 1 实验内容 2 实验流程 3 DNN模型 4 LeNet 模型 4.1LeNet-1模型 4.2 Lenet-4 模型 4.3 LeNet-5 模型 4.4 LeNet 模型的总结 4.5 LeNet 模型与DNN模型比较 5 模型的应用 5.1 自己的手写数字图片 5.2将手写的图片进行预处理 5.3调用训练好的模型进行预测 5.4 总结 1 实验内容 本次实验采用构造 DNN 模型与 LeNet 模型进行手写数字识别实验，采用经典手写数字识别数据集 MINI.
手把手教你，MNIST手写数字识别
张蔡辉
11-30 1万+
数据集介绍 MNIST数据集是机器学习领域中非常经典的一个数据集，由60000个训练样本和10000个测试样本组成，每个样本都是一张28 * 28像素的灰度手写数字图片，且内置于keras。本文采用Tensorflow下Keras（Keras中文文档）神经网络API进行网络搭建。 开始之前，先回忆下机器学习的通用工作流程（ ✅表示本文用到，❌表示本文没有用到 ) 定义问题，收集数据集（✅） 选择衡量成功的指标（✅） 确定评估的方法（✅） 准备数据（✅） 开发比基准更好的模型（❌） 扩大模型规模（❌） 模型
caffe --module=caffe.alexnet
06-02
`caffe --module=caffe.alexnet` 命令用于使用 Caffe 框架内置的 AlexNet 模型进行训练或测试。AlexNet 是一个经典的深度卷积神经网络模型，由 Alex Krizhevsky 等人在 2012 年 ImageNet 大规模视觉识别竞赛 (ILSVRC) 上取得了优异的成绩。 在使用 `caffe --module=caffe.alexnet` 命令时，需要指定相应的训练或测试配置文件，例如： ``` caffe --module=caffe.alexnet train \ --solver=path/to/solver.prototxt \ --weights=path/to/pretrained_model.caffemodel ``` 这个命令将使用 `caffe.alexnet` 模块进行训练，使用 `path/to/solver.prototxt` 文件指定训练参数，使用 `path/to/pretrained_model.caffemodel` 文件指定预训练模型权重。在测试时，可以使用类似的命令： ``` caffe --module=caffe.alexnet test \ --model=path/to/deploy.prototxt \ --weights=path/to/trained_model.caffemodel ``` 这个命令将使用 `caffe.alexnet` 模块进行测试，使用 `path/to/deploy.prototxt` 文件指定模型结构，使用 `path/to/trained_model.caffemodel` 文件指定训练后的模型权重。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值