如何对图像做分类器训练matlab代码

对图像做分类器训练要建立视觉词袋来进行图像分类。该过程生成用来表示图像视觉词的直方图，通过这些直方图来训练图像分类器。下面的步骤描述如何建立图像集，建立视觉词袋，以及训练和运用图像分类器。

第一步：建立图像类别集合

将图像分割成训练子集和测试子集。利用imageDatastore函数来存储训练分类器的图像。可以利用splitEachLabel函数将图像分割成训练数据和测试数据。

读取类别图像和创建图像子集

setDir = fullfile(toolboxdir('vision'),'visiondata','imageSets')

imds = imageDatastore(setDir,'IncludeSubfolders',true,'LabelSource','foldernames')

分割图集成训练和测试子集。下例中，30%作为训练数据，余下的作为测试数据。

[trainingSet,testSet] = splitEachLabel(imds,0.3,'randomize')

第二步：建立特征词袋

通过从每个类别的有代表性的图像中提取特征描述符，创建视觉词汇表或特征包。

通过在训练集合中提取出的特征描述符上利用k-means聚类算法，bagOfFeatures对象定义特征，视觉词汇。该算法迭代地将描述符分成k个互斥簇。由此产生的簇是紧密的，并具有相似的特性。每个集群中心代表一个特征，或一个可视词。可以基于特征检测器提取特征，也可以定义一个网格来提取特征描述符。网格方法可能丢失细节信息。因此，对不包含明显特征的图像使用网格，例如海滩等景物的图像。使用Speed up robust features（或SURF）检测器提供更大的尺度不变性。默认情况下，该算法运行“网格”方法。

该算法工作流对图像进行整体分析。图像必须有适当的标签来描述它们所代表的类。例如，一组汽车图像可以被标记为汽车。工作流不依赖于空间信息，也不依赖于标记图像中的特定对象。视觉词袋技术依赖于非局部化的检测技术。

第三步：通过视觉词袋训练图像分类器

trainImageCategoryClassifier函数返回一个图像分类器。该方法使用基于2分类支持向量机（SVM）的error-correcting output codes(ECOC)框架来训练一个多分类器。

该方法利用bagOfFeatures对象返回的视觉词袋将图像集中的图像编码成视觉词直方图。然后将视觉词直方图作为训练分类器的正负样本。

1、将训练集中的每幅图像利用bagOfFeature的encode方法进行编码。该函数检测和提取图像中的特征，然后利用最近邻算法构造每个图像的特征直方图。函数将描述符逼近聚类中心来增加直方图各bin的数值。直方图的长度取决于bagOfFeatures对象构造的出来的视觉词的数量。最终将直方图作为图像的特征向量。

2、对训练集中的每幅图像重复步骤1，建立训练数据

3、评价分类器。在测试图像集上使用imagecategoryclassifier的evaluate方法测试分类器。输出混淆矩阵可以分析预测结果。理想的分类结果是对角线上包含一个标准矩阵。不正确的分类导致出现分数值。

第四步：对图像或图像集进行分类

最后使用imageCategoryClassifier 的predeict方法对新图像进行分类来确定其类型。

matlab如何svm实现图像分类输出像素点，这里分享下 *** 作方法。

设备：华硕笔记本

系统：win10

软件：matlab2012

1、首先双击桌面matlab图标，打开matlab软件。

2、然后在打开的软件中，点击左上角新建m文件。

3、然后输入如图所示的代码。

4、最后点击运行程序，即可输出两幅图像像素点。

Caffe是目前深度学习比较优秀好用的一个开源库，采样c++和CUDA实现，具有速度快，模型定义方便等优点。学习了几天过后，发现也有一个不方便的地方，就是在我的程序中调用Caffe做图像分类没有直接的接口。Caffe的数据层可以从数据库（支持leveldb、lmdb、hdf5）、图片、和内存中读入。我们要在程序中使用，当然得从内存中读入，我们首先在模型定义文件中定义数据层：

layers {

name: "mydata"

type: MEMORY_DATA

top: "data"

top: "label"

transform_param {

scale: 0.00390625

}

memory_data_param {

batch_size: 10

channels: 1

height: 24

width: 24

}

}

这里必须设置memory_data_param中的四个参数，对应这些参数可以参见源码中caffe.proto文件。现在，我们可以设计一个Classifier类来封装一下：

#ifndef CAFFE_CLASSIFIER_H

#define CAFFE_CLASSIFIER_H

#include <string>

#include <vector>

#include "caffe/net.hpp"

#include "caffe/data_layers.hpp"

#include <opencv2/core.hpp>

using cv::Mat

namespace caffe {

template <typename Dtype>

class Classifier {

public:

explicit Classifier(const string&param_file, const string&weights_file)

Dtype test(vector<Mat>&images, vector<int>&labels, int iter_num)

virtual ~Classifier() {}

inline shared_ptr<Net<Dtype>>net() { return net_}

void predict(vector<Mat>&images, vector<int>*labels)

void predict(vector<Dtype>&data, vector<int>*labels, int num)

void extract_feature(vector<Mat>&images, vector<vector<Dtype>>*out)

protected:

shared_ptr<Net<Dtype>>net_

MemoryDataLayer<Dtype>*m_layer_

int batch_size_

int channels_

int height_

int width_

DISABLE_COPY_AND_ASSIGN(Classifier)

}

}//namespace

#endif //CAFFE_CLASSIFIER_H

构造函数中我们通过模型定义文件（.prototxt）和训练好的模型（.caffemodel）文件构造一个Net对象，并用m_layer_指向Net中的memory data层，以便待会调用MemoryDataLayer中AddMatVector和Reset函数加入数据。

#include <cstdio>

#include <algorithm>

#include <string>

#include <vector>

#include "caffe/net.hpp"

#include "caffe/proto/caffe.pb.h"

#include "caffe/util/io.hpp"

#include "caffe/util/math_functions.hpp"

#include "caffe/util/upgrade_proto.hpp"

#include "caffe_classifier.h"

namespace caffe {

template <typename Dtype>

Classifier<Dtype>::Classifier(const string&param_file, const string&weights_file) : net_()

{

net_.reset(new Net<Dtype>(param_file, TEST))

net_->CopyTrainedLayersFrom(weights_file)

//m_layer_ = (MemoryDataLayer<Dtype>*)net_->layer_by_name("mnist").get()

m_layer_ = (MemoryDataLayer<Dtype>*)net_->layers()[0].get()

batch_size_ = m_layer_->batch_size()

channels_ = m_layer_->channels()

height_ = m_layer_->height()

width_ = m_layer_->width()

}

template <typename Dtype>

Dtype Classifier<Dtype>::test(vector<Mat>&images, vector<int>&labels, int iter_num)

{

m_layer_->AddMatVector(images, labels)

//

int iterations = iter_num

vector<Blob<Dtype>* >bottom_vec

vector<int>test_score_output_id

vector<Dtype>test_score

Dtype loss = 0

for (int i = 0i <iterations++i) {

Dtype iter_loss

const vector<Blob<Dtype>*>&result =

net_->Forward(bottom_vec, &iter_loss)

loss += iter_loss

int idx = 0

for (int j = 0j <result.size()++j) {

const Dtype* result_vec = result[j]->cpu_data()

for (int k = 0k <result[j]->count()++k, ++idx) {

const Dtype score = result_vec[k]

if (i == 0) {

test_score.push_back(score)

test_score_output_id.push_back(j)

} else {

test_score[idx] += score

}

const std::string&output_name = net_->blob_names()[

net_->output_blob_indices()[j]]

LOG(INFO) <<"Batch " <<i <<", " <<output_name <<" = " <<score

}

}

}

loss /= iterations

LOG(INFO) <<"Loss: " <<loss

return loss

}

template <typename Dtype>

void Classifier<Dtype>::predict(vector<Mat>&images, vector<int>*labels)

{

int original_length = images.size()

if(original_length == 0)

return

int valid_length = original_length / batch_size_ * batch_size_

if(original_length != valid_length)

{

valid_length += batch_size_

for(int i = original_lengthi <valid_lengthi++)

{

images.push_back(images[0].clone())

}

}

vector<int>valid_labels, predicted_labels

valid_labels.resize(valid_length, 0)

m_layer_->AddMatVector(images, valid_labels)

vector<Blob<Dtype>* >bottom_vec

for(int i = 0i <valid_length / batch_size_i++)

{

const vector<Blob<Dtype>*>&result = net_->Forward(bottom_vec)

const Dtype * result_vec = result[1]->cpu_data()

for(int j = 0j <result[1]->count()j++)

{

predicted_labels.push_back(result_vec[j])

}

}

if(original_length != valid_length)

{

images.erase(images.begin()+original_length, images.end())

}

labels->resize(original_length, 0)

std::copy(predicted_labels.begin(), predicted_labels.begin() + original_length, labels->begin())

}

template <typename Dtype>

void Classifier<Dtype>::predict(vector<Dtype>&data, vector<int>*labels, int num)

{

int size = channels_*height_*width_

CHECK_EQ(data.size(), num*size)

int original_length = num

if(original_length == 0)

return

int valid_length = original_length / batch_size_ * batch_size_

if(original_length != valid_length)

{

valid_length += batch_size_

for(int i = original_lengthi <valid_lengthi++)

{

for(int j = 0j <sizej++)

data.push_back(0)

}

}

---