非線形分離可能なデータに対するサポートベクターマシン

目次

• 目的
• 動機
• 最適化問題の拡張
• ソースコード
• 解説
• 結果

前のチュートリアル: サポートベクターマシン入門

原著者	Fernando Iglesias García
互換性	OpenCV >= 3.0

目的

このチュートリアルでは、以下の方法を学ぶ:

• 訓練データを線形に分離できない場合のSVMの最適化問題を定義する。
• この種の問題に合わせてSVMを適応させるための引数の設定方法。

動機

線形分離できない訓練データを扱うためにSVMの最適化問題を拡張することには、なぜ意義があるのか。コンピュータビジョンでSVMが用いられる用途の多くは、単純な線形分類器よりも強力なツールを必要とする。これは、こうしたタスクでは 訓練データを超平面で分離できることはまれである という事実に起因する。

こうしたタスクの一つ、たとえば顔検出を考えてみる。この場合の訓練データは、顔である画像の集合と、顔でない画像の集合（顔以外のあらゆるもの）から構成される。この訓練データは非常に複雑であり、顔の集合全体を顔でない集合全体から線形に分離できるような各サンプルの表現（特徴ベクトル）を見つけることは困難である。

最適化問題の拡張

SVMによって分離超平面が得られることを思い出してほしい。したがって、訓練データが線形分離できない以上、見つかった超平面はサンプルの一部を誤分類することを認めざるを得ない。この 誤分類 は、考慮すべき最適化の新たな変数となる。新しいモデルには、最大のマージンを与える超平面を見つけるという従来の要件と、分類誤りを過度に許容せずに訓練データを正しく汎化するという新たな要件の両方を含める必要がある。

ここでは、マージン を最大化する超平面を求める最適化問題の定式化から出発する（これは前のチュートリアル（サポートベクターマシン入門）で説明されている）。

\[\min_{\beta, \beta_{0}} L(\beta) = \frac{1}{2}||\beta||^{2} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 \text{ } \forall i\]

このモデルを修正して誤分類誤差を考慮に入れる方法は複数ある。たとえば、同じ量に、訓練データ中の誤分類誤差の数に定数を掛けたものを加えて最小化することが考えられる。すなわち:

\[\min ||\beta||^{2} + C \text{(misclassification errors)}\]

しかし、これはあまり良い解ではない。いくつかの理由があるが、その一つとして、本来属すべき決定領域からわずかな距離で誤分類されたサンプルと、そうでないサンプルを区別していないことが挙げられる。したがって、より良い解は 誤分類されたサンプルから正しい決定領域までの距離 を考慮する。すなわち:

\[\min ||\beta||^{2} + C \text{(distance of misclassified samples to their correct regions)}\]

訓練データの各サンプルに対して、新たな引数 \(\xi_{i}\) を定義する。これらの引数はそれぞれ、対応する訓練サンプルから正しい決定領域までの距離を保持する。次の図は、2つのクラスからなる線形分離できない訓練データ、分離超平面、および誤分類されたサンプルから正しい領域までの距離を示している。

覚え書き

図には、誤分類されたサンプルの距離のみが示されている。残りのサンプルの距離は、すでに正しい決定領域内に位置しているためゼロである。

図に現れる赤線と青線は、各決定領域に対するマージンである。各 \(\xi_{i}\) が、誤分類された訓練サンプルから、本来属すべき領域のマージンまでを表していることを理解することが非常に 重要 である。

最終的に、最適化問題の新しい定式化は次のようになる:

\[\min_{\beta, \beta_{0}} L(\beta) = ||\beta||^{2} + C \sum_{i} {\xi_{i}} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 - \xi_{i} \text{ and } \xi_{i} \geq 0 \text{ } \forall i\]

引数 C はどのように選べばよいのか。この問いの答えが訓練データの分布の仕方に依存することは明らかである。一般的な答えはないが、次の規則を考慮に入れると役立つ:

• C を大きくすると、誤分類誤差は少ない が マージンが小さい 解が得られる。この場合、誤分類誤差を起こすコストが高いことに注意する。最適化の目的は引数を最小化することなので、誤分類誤差はほとんど許容されない。
• C を小さくすると、マージンが大きく、分類誤差が多い 解が得られる。この場合、最小化は和の項をあまり重視しないため、大きなマージンを持つ超平面を見つけることにより重点が置かれる。

ソースコード

ソースコードはOpenCVソースライブラリの ml/samples フォルダにもある。あるいは ここからダウンロード できる。

C++

• ダウンロード可能なコード: ここ をクリック
• コードの概要:

  #include <iostream>
  #include <opencv2/core.hpp>
  #include <opencv2/imgproc.hpp>
  #include "opencv2/imgcodecs.hpp"
  #include <opencv2/highgui.hpp>
  #include <opencv2/ml.hpp>
   
  using namespace cv;
  using namespace cv::ml;
  using namespace std;
   
  static void help()
  {
   cout<< "\n--------------------------------------------------------------------------" << endl
   << "This program shows Support Vector Machines for Non-Linearly Separable Data. " << endl
   << "--------------------------------------------------------------------------" << endl
   << endl;
  }
   
  int main()
  {
   help();
   
   const int NTRAINING_SAMPLES = 100; // Number of training samples per class
   const float FRAC_LINEAR_SEP = 0.9f; // Fraction of samples which compose the linear separable part
   
   // Data for visual representation
   const int WIDTH = 512, HEIGHT = 512;
   Mat I = Mat::zeros(HEIGHT, WIDTH, CV_8UC3);
   
   //--------------------- 1. Set up training data randomly ---------------------------------------
   Mat trainData(2*NTRAINING_SAMPLES, 2, CV_32F);
   Mat labels (2*NTRAINING_SAMPLES, 1, CV_32S);
   
   RNG rng(100); // Random value generation class
   
   // Set up the linearly separable part of the training data
   int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);
   
   // Generate random points for the class 1
   Mat trainClass = trainData.rowRange(0, nLinearSamples);
   // The x coordinate of the points is in [0, 0.4)
   Mat c = trainClass.colRange(0, 1);
   rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(0.4 * WIDTH));
   // The y coordinate of the points is in [0, 1)
   c = trainClass.colRange(1,2);
   rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
   
   // Generate random points for the class 2
   trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
   // The x coordinate of the points is in [0.6, 1]
   c = trainClass.colRange(0 , 1);
   rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
   // The y coordinate of the points is in [0, 1)
   c = trainClass.colRange(1,2);
   rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
   
   //------------------ Set up the non-linearly separable part of the training data ---------------
   // Generate random points for the classes 1 and 2
   trainClass = trainData.rowRange(nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
   // The x coordinate of the points is in [0.4, 0.6)
   c = trainClass.colRange(0,1);
   rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
   // The y coordinate of the points is in [0, 1)
   c = trainClass.colRange(1,2);
   rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
   
   //------------------------- Set up the labels for the classes ---------------------------------
   labels.rowRange( 0, NTRAINING_SAMPLES).setTo(1); // Class 1
   labels.rowRange(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES).setTo(2); // Class 2
   
   //------------------------ 2. Set up the support vector machines parameters --------------------
   cout << "Starting training process" << endl;
   Ptr<SVM> svm = SVM::create();
   svm->setType(SVM::C_SVC);
   svm->setC(0.1);
   svm->setKernel(SVM::LINEAR);
   svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6));
   
   //------------------------ 3. Train the svm ----------------------------------------------------
   svm->train(trainData, ROW_SAMPLE, labels);
   cout << "Finished training process" << endl;
   
   //------------------------ 4. Show the decision regions ----------------------------------------
   Vec3b green(0,100,0), blue(100,0,0);
   for (int i = 0; i < I.rows; i++)
   {
   for (int j = 0; j < I.cols; j++)
   {
   Mat sampleMat = (Mat_<float>(1,2) << j, i);
   float response = svm->predict(sampleMat);
   
   if (response == 1) I.at<Vec3b>(i,j) = green;
   else if (response == 2) I.at<Vec3b>(i,j) = blue;
   }
   }
   
   //----------------------- 5. Show the training data --------------------------------------------
   int thick = -1;
   float px, py;
   // Class 1
   for (int i = 0; i < NTRAINING_SAMPLES; i++)
   {
   px = trainData.at<float>(i,0);
   py = trainData.at<float>(i,1);
   circle(I, Point( (int) px, (int) py ), 3, Scalar(0, 255, 0), thick);
   }
   // Class 2
   for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; i++)
   {
   px = trainData.at<float>(i,0);
   py = trainData.at<float>(i,1);
   circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick);
   }
   
   //------------------------- 6. Show support vectors --------------------------------------------
   thick = 2;
   Mat sv = svm->getUncompressedSupportVectors();
   
   for (int i = 0; i < sv.rows; i++)
   {
   const float* v = sv.ptr<float>(i);
   circle(I, Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick);
   }
   
   imwrite("result.png", I); // save the Image
   imshow("SVM for Non-Linear Training Data", I); // show it to the user
   waitKey();
   return 0;
  }

Java

• ダウンロード可能なコード: ここ をクリック
• コードの概要:

  import java.util.Random;
   
  import org.opencv.core.Core;
  import org.opencv.core.CvType;
  import org.opencv.core.Mat;
  import org.opencv.core.Point;
  import org.opencv.core.Scalar;
  import org.opencv.core.TermCriteria;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgcodecs.Imgcodecs;
  import org.opencv.imgproc.Imgproc;
  import org.opencv.ml.Ml;
  import org.opencv.ml.SVM;
   
  public class NonLinearSVMsDemo {
   public static final int NTRAINING_SAMPLES = 100;
   public static final float FRAC_LINEAR_SEP = 0.9f;
   
   public static void main(String[] args) {
   // Load the native OpenCV library
   System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
   
   System.out.println("\n--------------------------------------------------------------------------");
   System.out.println("This program shows Support Vector Machines for Non-Linearly Separable Data. ");
   System.out.println("--------------------------------------------------------------------------\n");
   
   // Data for visual representation
   int width = 512, height = 512;
   Mat I = Mat.zeros(height, width, CvType.CV_8UC3);
   
   // --------------------- 1. Set up training data randomly---------------------------------------
   Mat trainData = new Mat(2 * NTRAINING_SAMPLES, 2, CvType.CV_32F);
   Mat labels = new Mat(2 * NTRAINING_SAMPLES, 1, CvType.CV_32S);
   
   Random rng = new Random(100); // Random value generation class
   
   // Set up the linearly separable part of the training data
   int nLinearSamples = (int) (FRAC_LINEAR_SEP * NTRAINING_SAMPLES);
   
   // Generate random points for the class 1
   Mat trainClass = trainData.rowRange(0, nLinearSamples);
   // The x coordinate of the points is in [0, 0.4)
   Mat c = trainClass.colRange(0, 1);
   float[] cData = new float[(int) (c.total() * c.channels())];
   double[] cDataDbl = rng.doubles(cData.length, 0, 0.4f * width).toArray();
   for (int i = 0; i < cData.length; i++) {
   cData[i] = (float) cDataDbl[i];
   }
   c.put(0, 0, cData);
   // The y coordinate of the points is in [0, 1)
   c = trainClass.colRange(1, 2);
   cData = new float[(int) (c.total() * c.channels())];
   cDataDbl = rng.doubles(cData.length, 0, height).toArray();
   for (int i = 0; i < cData.length; i++) {
   cData[i] = (float) cDataDbl[i];
   }
   c.put(0, 0, cData);
   
   // Generate random points for the class 2
   trainClass = trainData.rowRange(2 * NTRAINING_SAMPLES - nLinearSamples, 2 * NTRAINING_SAMPLES);
   // The x coordinate of the points is in [0.6, 1]
   c = trainClass.colRange(0, 1);
   cData = new float[(int) (c.total() * c.channels())];
   cDataDbl = rng.doubles(cData.length, 0.6 * width, width).toArray();
   for (int i = 0; i < cData.length; i++) {
   cData[i] = (float) cDataDbl[i];
   }
   c.put(0, 0, cData);
   // The y coordinate of the points is in [0, 1)
   c = trainClass.colRange(1, 2);
   cData = new float[(int) (c.total() * c.channels())];
   cDataDbl = rng.doubles(cData.length, 0, height).toArray();
   for (int i = 0; i < cData.length; i++) {
   cData[i] = (float) cDataDbl[i];
   }
   c.put(0, 0, cData);
   
   // ------------------ Set up the non-linearly separable part of the training data ---------------
   // Generate random points for the classes 1 and 2
   trainClass = trainData.rowRange(nLinearSamples, 2 * NTRAINING_SAMPLES - nLinearSamples);
   // The x coordinate of the points is in [0.4, 0.6)
   c = trainClass.colRange(0, 1);
   cData = new float[(int) (c.total() * c.channels())];
   cDataDbl = rng.doubles(cData.length, 0.4 * width, 0.6 * width).toArray();
   for (int i = 0; i < cData.length; i++) {
   cData[i] = (float) cDataDbl[i];
   }
   c.put(0, 0, cData);
   // The y coordinate of the points is in [0, 1)
   c = trainClass.colRange(1, 2);
   cData = new float[(int) (c.total() * c.channels())];
   cDataDbl = rng.doubles(cData.length, 0, height).toArray();
   for (int i = 0; i < cData.length; i++) {
   cData[i] = (float) cDataDbl[i];
   }
   c.put(0, 0, cData);
   
   // ------------------------- Set up the labels for the classes---------------------------------
   labels.rowRange(0, NTRAINING_SAMPLES).setTo(new Scalar(1)); // Class 1
   labels.rowRange(NTRAINING_SAMPLES, 2 * NTRAINING_SAMPLES).setTo(new Scalar(2)); // Class 2
   
   // ------------------------ 2. Set up the support vector machines parameters--------------------
   System.out.println("Starting training process");
   SVM svm = SVM.create();
   svm.setType(SVM.C_SVC);
   svm.setC(0.1);
   svm.setKernel(SVM.LINEAR);
   svm.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, (int) 1e7, 1e-6));
   
   // ------------------------ 3. Train the svm----------------------------------------------------
   svm.train(trainData, Ml.ROW_SAMPLE, labels);
   System.out.println("Finished training process");
   
   // ------------------------ 4. Show the decision regions----------------------------------------
   byte[] IData = new byte[(int) (I.total() * I.channels())];
   Mat sampleMat = new Mat(1, 2, CvType.CV_32F);
   float[] sampleMatData = new float[(int) (sampleMat.total() * sampleMat.channels())];
   for (int i = 0; i < I.rows(); i++) {
   for (int j = 0; j < I.cols(); j++) {
   sampleMatData[0] = j;
   sampleMatData[1] = i;
   sampleMat.put(0, 0, sampleMatData);
   float response = svm.predict(sampleMat);
   
   if (response == 1) {
   IData[(i * I.cols() + j) * I.channels()] = 0;
   IData[(i * I.cols() + j) * I.channels() + 1] = 100;
   IData[(i * I.cols() + j) * I.channels() + 2] = 0;
   } else if (response == 2) {
   IData[(i * I.cols() + j) * I.channels()] = 100;
   IData[(i * I.cols() + j) * I.channels() + 1] = 0;
   IData[(i * I.cols() + j) * I.channels() + 2] = 0;
   }
   }
   }
   I.put(0, 0, IData);
   
   // ----------------------- 5. Show the training data--------------------------------------------
   int thick = -1;
   int lineType = Imgproc.LINE_8;
   float px, py;
   // Class 1
   float[] trainDataData = new float[(int) (trainData.total() * trainData.channels())];
   trainData.get(0, 0, trainDataData);
   for (int i = 0; i < NTRAINING_SAMPLES; i++) {
   px = trainDataData[i * trainData.cols()];
   py = trainDataData[i * trainData.cols() + 1];
   Imgproc.circle(I, new Point(px, py), 3, new Scalar(0, 255, 0), thick, lineType, 0);
   }
   // Class 2
   for (int i = NTRAINING_SAMPLES; i < 2 * NTRAINING_SAMPLES; ++i) {
   px = trainDataData[i * trainData.cols()];
   py = trainDataData[i * trainData.cols() + 1];
   Imgproc.circle(I, new Point(px, py), 3, new Scalar(255, 0, 0), thick, lineType, 0);
   }
   
   // ------------------------- 6. Show support vectors--------------------------------------------
   thick = 2;
   Mat sv = svm.getUncompressedSupportVectors();
   float[] svData = new float[(int) (sv.total() * sv.channels())];
   sv.get(0, 0, svData);
   for (int i = 0; i < sv.rows(); i++) {
   Imgproc.circle(I, new Point(svData[i * sv.cols()], svData[i * sv.cols() + 1]), 6, new Scalar(128, 128, 128),
   thick, lineType, 0);
   }
   
   Imgcodecs.imwrite("result.png", I); // save the Image
   HighGui.imshow("SVM for Non-Linear Training Data", I); // show it to the user
   HighGui.waitKey();
   System.exit(0);
   }
  }

Python

• ダウンロード可能なコード: ここ をクリック
• Code at glance:

  from __future__ import print_function
  import cv2 as cv
  import numpy as np
  import random as rng
   
  NTRAINING_SAMPLES = 100 # Number of training samples per class
  FRAC_LINEAR_SEP = 0.9 # Fraction of samples which compose the linear separable part
   
  # Data for visual representation
  WIDTH = 512
  HEIGHT = 512
  I = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
   
  # --------------------- 1. Set up training data randomly ---------------------------------------
  trainData = np.empty((2*NTRAINING_SAMPLES, 2), dtype=np.float32)
  labels = np.empty((2*NTRAINING_SAMPLES, 1), dtype=np.int32)
   
  rng.seed(100) # Random value generation class
   
  # Set up the linearly separable part of the training data
  nLinearSamples = int(FRAC_LINEAR_SEP * NTRAINING_SAMPLES)
   
   
  trainClass = trainData[0:nLinearSamples,:]
  # The x coordinate of the points is in [0, 0.4)
  c = trainClass[:,0:1]
  c[:] = np.random.uniform(0.0, 0.4 * WIDTH, c.shape)
  # The y coordinate of the points is in [0, 1)
  c = trainClass[:,1:2]
  c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
   
  # Generate random points for the class 2
  trainClass = trainData[2*NTRAINING_SAMPLES-nLinearSamples:2*NTRAINING_SAMPLES,:]
  # The x coordinate of the points is in [0.6, 1]
  c = trainClass[:,0:1]
  c[:] = np.random.uniform(0.6*WIDTH, WIDTH, c.shape)
  # The y coordinate of the points is in [0, 1)
  c = trainClass[:,1:2]
  c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
   
   
  #------------------ Set up the non-linearly separable part of the training data ---------------
   
  trainClass = trainData[nLinearSamples:2*NTRAINING_SAMPLES-nLinearSamples,:]
  # The x coordinate of the points is in [0.4, 0.6)
  c = trainClass[:,0:1]
  c[:] = np.random.uniform(0.4*WIDTH, 0.6*WIDTH, c.shape)
  # The y coordinate of the points is in [0, 1)
  c = trainClass[:,1:2]
  c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
   
   
  #------------------------- Set up the labels for the classes ---------------------------------
  labels[0:NTRAINING_SAMPLES,:] = 1 # Class 1
  labels[NTRAINING_SAMPLES:2*NTRAINING_SAMPLES,:] = 2 # Class 2
   
  #------------------------ 2. Set up the support vector machines parameters --------------------
  print('Starting training process')
   
  svm = cv.ml.SVM_create()
  svm.setType(cv.ml.SVM_C_SVC)
  svm.setC(0.1)
  svm.setKernel(cv.ml.SVM_LINEAR)
  svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, int(1e7), 1e-6))
   
   
  #------------------------ 3. Train the svm ----------------------------------------------------
   
  svm.train(trainData, cv.ml.ROW_SAMPLE, labels)
   
  print('Finished training process')
   
  #------------------------ 4. Show the decision regions ----------------------------------------
   
  green = (0,100,0)
  blue = (100,0,0)
  for i in range(I.shape[0]):
   for j in range(I.shape[1]):
   sampleMat = np.matrix([[j,i]], dtype=np.float32)
   response = svm.predict(sampleMat)[1]
   
   if response == 1:
   I[i,j] = green
   elif response == 2:
   I[i,j] = blue
   
   
  #----------------------- 5. Show the training data --------------------------------------------
   
  thick = -1
  # Class 1
  for i in range(NTRAINING_SAMPLES):
   px = trainData[i,0]
   py = trainData[i,1]
   cv.circle(I, (int(px), int(py)), 3, (0, 255, 0), thick)
   
  # Class 2
  for i in range(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES):
   px = trainData[i,0]
   py = trainData[i,1]
   cv.circle(I, (int(px), int(py)), 3, (255, 0, 0), thick)
   
   
  #------------------------- 6. Show support vectors --------------------------------------------
   
  thick = 2
  sv = svm.getUncompressedSupportVectors()
   
  for i in range(sv.shape[0]):
   cv.circle(I, (int(sv[i,0]), int(sv[i,1])), 6, (128, 128, 128), thick)
   
   
  cv.imwrite('result.png', I) # save the Image
  cv.imshow('SVM for Non-Linear Training Data', I) # show it to the user
  cv.waitKey()

解説

• 訓練データを設定する

この演習の訓練データは、2つの異なるクラスのいずれかに属する、ラベル付き2D点の集合で構成される。演習をより興味深いものにするため、訓練データは一様確率密度関数 (PDF) を用いてランダムに生成される。

訓練データの生成は2つの主要な部分に分けている。

最初の部分では、両クラスについて線形分離可能なデータを生成する。

C++

 // Generate random points for the class 1
 Mat trainClass = trainData.rowRange(0, nLinearSamples);
 // The x coordinate of the points is in [0, 0.4)
 Mat c = trainClass.colRange(0, 1);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(0.4 * WIDTH));
 // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));
 
 // Generate random points for the class 2
    trainClass = trainData.rowRange(2*NTRAINING_SAMPLES-nLinearSamples, 2*NTRAINING_SAMPLES);
 // The x coordinate of the points is in [0.6, 1]
    c = trainClass.colRange(0 , 1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.6*WIDTH), Scalar(WIDTH));
 // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));

Java

 // Generate random points for the class 1
        Mat trainClass = trainData.rowRange(0, nLinearSamples);
 // The x coordinate of the points is in [0, 0.4)
        Mat c = trainClass.colRange(0, 1);
 float[] cData = new float[(int) (c.total() * c.channels())];
 double[] cDataDbl = rng.doubles(cData.length, 0, 0.4f * width).toArray();
 for (int i = 0; i < cData.length; i++) {
            cData[i] = (float) cDataDbl[i];
        }
        c.put(0, 0, cData);
 // The y coordinate of the points is in [0, 1)
        c = trainClass.colRange(1, 2);
        cData = new float[(int) (c.total() * c.channels())];
        cDataDbl = rng.doubles(cData.length, 0, height).toArray();
 for (int i = 0; i < cData.length; i++) {
            cData[i] = (float) cDataDbl[i];
        }
        c.put(0, 0, cData);
 
 // Generate random points for the class 2
        trainClass = trainData.rowRange(2 * NTRAINING_SAMPLES - nLinearSamples, 2 * NTRAINING_SAMPLES);
 // The x coordinate of the points is in [0.6, 1]
        c = trainClass.colRange(0, 1);
        cData = new float[(int) (c.total() * c.channels())];
        cDataDbl = rng.doubles(cData.length, 0.6 * width, width).toArray();
 for (int i = 0; i < cData.length; i++) {
            cData[i] = (float) cDataDbl[i];
        }
        c.put(0, 0, cData);
 // The y coordinate of the points is in [0, 1)
        c = trainClass.colRange(1, 2);
        cData = new float[(int) (c.total() * c.channels())];
        cDataDbl = rng.doubles(cData.length, 0, height).toArray();
 for (int i = 0; i < cData.length; i++) {
            cData[i] = (float) cDataDbl[i];
        }
        c.put(0, 0, cData);

Python

trainClass = trainData[0:nLinearSamples,:]
# The x coordinate of the points is in [0, 0.4)
c = trainClass[:,0:1]
c[:] = np.random.uniform(0.0, 0.4 * WIDTH, c.shape)
# The y coordinate of the points is in [0, 1)
c = trainClass[:,1:2]
c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
 
# Generate random points for the class 2
trainClass = trainData[2*NTRAINING_SAMPLES-nLinearSamples:2*NTRAINING_SAMPLES,:]
# The x coordinate of the points is in [0.6, 1]
c = trainClass[:,0:1]
c[:] = np.random.uniform(0.6*WIDTH, WIDTH, c.shape)
# The y coordinate of the points is in [0, 1)
c = trainClass[:,1:2]
c[:] = np.random.uniform(0.0, HEIGHT, c.shape)

2番目の部分では、両クラスについて線形分離できない、重なり合うデータを生成する。

C++

 // Generate random points for the classes 1 and 2
    trainClass = trainData.rowRange(nLinearSamples, 2*NTRAINING_SAMPLES-nLinearSamples);
 // The x coordinate of the points is in [0.4, 0.6)
    c = trainClass.colRange(0,1);
    rng.fill(c, RNG::UNIFORM, Scalar(0.4*WIDTH), Scalar(0.6*WIDTH));
 // The y coordinate of the points is in [0, 1)
    c = trainClass.colRange(1,2);
    rng.fill(c, RNG::UNIFORM, Scalar(0), Scalar(HEIGHT));

Java

 // Generate random points for the classes 1 and 2
        trainClass = trainData.rowRange(nLinearSamples, 2 * NTRAINING_SAMPLES - nLinearSamples);
 // The x coordinate of the points is in [0.4, 0.6)
        c = trainClass.colRange(0, 1);
        cData = new float[(int) (c.total() * c.channels())];
        cDataDbl = rng.doubles(cData.length, 0.4 * width, 0.6 * width).toArray();
 for (int i = 0; i < cData.length; i++) {
            cData[i] = (float) cDataDbl[i];
        }
        c.put(0, 0, cData);
 // The y coordinate of the points is in [0, 1)
        c = trainClass.colRange(1, 2);
        cData = new float[(int) (c.total() * c.channels())];
        cDataDbl = rng.doubles(cData.length, 0, height).toArray();
 for (int i = 0; i < cData.length; i++) {
            cData[i] = (float) cDataDbl[i];
        }
        c.put(0, 0, cData);

Python

trainClass = trainData[nLinearSamples:2*NTRAINING_SAMPLES-nLinearSamples,:]
# The x coordinate of the points is in [0.4, 0.6)
c = trainClass[:,0:1]
c[:] = np.random.uniform(0.4*WIDTH, 0.6*WIDTH, c.shape)
# The y coordinate of the points is in [0, 1)
c = trainClass[:,1:2]
c[:] = np.random.uniform(0.0, HEIGHT, c.shape)

• SVMの引数を設定する

覚え書き

前のチュートリアル サポートベクターマシン入門 では、ここでSVMを訓練する前に設定する cv::ml::SVM クラスの属性について説明している。

C++

 Ptr<SVM> svm = SVM::create();
    svm->setType(SVM::C_SVC);
    svm->setC(0.1);
    svm->setKernel(SVM::LINEAR);
    svm->setTermCriteria(TermCriteria(TermCriteria::MAX_ITER, (int)1e7, 1e-6));

Java

        SVM svm = SVM.create();
        svm.setType(SVM.C_SVC);
        svm.setC(0.1);
        svm.setKernel(SVM.LINEAR);
        svm.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, (int) 1e7, 1e-6));

Python

svm = cv.ml.SVM_create()
svm.setType(cv.ml.SVM_C_SVC)
svm.setC(0.1)
svm.setKernel(cv.ml.SVM_LINEAR)
svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, int(1e7), 1e-6))

ここで行う設定と、参照元とする前のチュートリアル（サポートベクターマシン入門）で行った設定との違いは、わずか2点だけである。

• C。ここでは、最適化において誤分類誤差を過度に罰しないよう、この引数に小さな値を選んだ。これは、直感的に期待される解に近いものを得たいという考えに基づいている。ただし、この引数を調整して問題への理解を深めることを推奨する。

  覚え書き

  この場合、クラス間の重なり領域にある点はごくわずかしかない。FRAC_LINEAR_SEP に小さい値を与えれば点の密度を高めることができ、引数 C の影響をより深く調べられる。

• アルゴリズムの終了条件。線形分離できない訓練データを含む問題を正しく解くには、最大反復回数を大幅に増やす必要がある。具体的には、この値を5桁分大きくした。
• SVMを訓練する

SVMモデルを構築するために cv::ml::SVM::train メソッドを呼び出す。訓練処理にはかなり長い時間がかかる場合があることに注意する。プログラムを実行する際は気長に待ってほしい。

C++

    svm->train(trainData, ROW_SAMPLE, labels);

Java

        svm.train(trainData, Ml.ROW_SAMPLE, labels);

Python

svm.train(trainData, cv.ml.ROW_SAMPLE, labels)

• 決定領域を表示する

cv::ml::SVM::predict メソッドは、訓練済みSVMを用いて入力サンプルを分類するために使われる。この例では、SVMが行った予測に応じて空間に色を付けるためにこのメソッドを使用した。言い換えると、画像を走査し、その各ピクセルをデカルト平面上の点として解釈する。各点は、SVMが予測したクラスに応じて色付けされ、ラベル1のクラスであれば濃い緑、ラベル2のクラスであれば濃い青で表示される。

C++

 Vec3b green(0,100,0), blue(100,0,0);
 for (int i = 0; i < I.rows; i++)
    {
 for (int j = 0; j < I.cols; j++)
        {
 Mat sampleMat = (Mat_<float>(1,2) << j, i);
 float response = svm->predict(sampleMat);
 
 if      (response == 1) I.at<Vec3b>(i,j) = green;
 else if (response == 2) I.at<Vec3b>(i,j) = blue;
        }
    }

Java

 byte[] IData = new byte[(int) (I.total() * I.channels())];
        Mat sampleMat = new Mat(1, 2, CvType.CV_32F);
 float[] sampleMatData = new float[(int) (sampleMat.total() * sampleMat.channels())];
 for (int i = 0; i < I.rows(); i++) {
 for (int j = 0; j < I.cols(); j++) {
                sampleMatData[0] = j;
                sampleMatData[1] = i;
                sampleMat.put(0, 0, sampleMatData);
 float response = svm.predict(sampleMat);
 
 if (response == 1) {
                    IData[(i * I.cols() + j) * I.channels()] = 0;
                    IData[(i * I.cols() + j) * I.channels() + 1] = 100;
                    IData[(i * I.cols() + j) * I.channels() + 2] = 0;
                } else if (response == 2) {
                    IData[(i * I.cols() + j) * I.channels()] = 100;
                    IData[(i * I.cols() + j) * I.channels() + 1] = 0;
                    IData[(i * I.cols() + j) * I.channels() + 2] = 0;
                }
            }
        }
        I.put(0, 0, IData);

Python

green = (0,100,0)
blue = (100,0,0)
for i in range(I.shape[0]):
 for j in range(I.shape[1]):
        sampleMat = np.matrix([[j,i]], dtype=np.float32)
        response = svm.predict(sampleMat)[1]
 
 if response == 1:
            I[i,j] = green
 elif response == 2:
            I[i,j] = blue

• 訓練データを表示する

cv::circle メソッドは、訓練データを構成するサンプルを表示するために使われる。ラベル1のクラスのサンプルは薄い緑で、ラベル2のクラスのサンプルは薄い青で表示される。

C++

 int thick = -1;
 float px, py;
 // Class 1
 for (int i = 0; i < NTRAINING_SAMPLES; i++)
    {
        px = trainData.at<float>(i,0);
        py = trainData.at<float>(i,1);
 circle(I, Point( (int) px,  (int) py ), 3, Scalar(0, 255, 0), thick);
    }
 // Class 2
 for (int i = NTRAINING_SAMPLES; i <2*NTRAINING_SAMPLES; i++)
    {
        px = trainData.at<float>(i,0);
        py = trainData.at<float>(i,1);
 circle(I, Point( (int) px, (int) py ), 3, Scalar(255, 0, 0), thick);
    }

Java

 int thick = -1;
 int lineType = Imgproc.LINE_8;
 float px, py;
 // Class 1
 float[] trainDataData = new float[(int) (trainData.total() * trainData.channels())];
        trainData.get(0, 0, trainDataData);
 for (int i = 0; i < NTRAINING_SAMPLES; i++) {
            px = trainDataData[i * trainData.cols()];
            py = trainDataData[i * trainData.cols() + 1];
            Imgproc.circle(I, new Point(px, py), 3, new Scalar(0, 255, 0), thick, lineType, 0);
        }
 // Class 2
 for (int i = NTRAINING_SAMPLES; i < 2 * NTRAINING_SAMPLES; ++i) {
            px = trainDataData[i * trainData.cols()];
            py = trainDataData[i * trainData.cols() + 1];
            Imgproc.circle(I, new Point(px, py), 3, new Scalar(255, 0, 0), thick, lineType, 0);
        }

Python

thick = -1
# Class 1
for i in range(NTRAINING_SAMPLES):
    px = trainData[i,0]
    py = trainData[i,1]
 cv.circle(I, (int(px), int(py)), 3, (0, 255, 0), thick)
 
# Class 2
for i in range(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES):
    px = trainData[i,0]
    py = trainData[i,1]
 cv.circle(I, (int(px), int(py)), 3, (255, 0, 0), thick)

• サポートベクトル

ここでは、サポートベクトルに関する情報を得るためにいくつかのメソッドを使用する。cv::ml::SVM::getSupportVectors メソッドはすべてのサポートベクトルを取得する。ここでは、このメソッドを使ってサポートベクトルである訓練サンプルを見つけ、それらを強調表示している。

C++

    thick = 2;
 Mat sv = svm->getUncompressedSupportVectors();
 
 for (int i = 0; i < sv.rows; i++)
    {
 const float* v = sv.ptr<float>(i);
 circle(I,  Point( (int) v[0], (int) v[1]), 6, Scalar(128, 128, 128), thick);
    }

Java

        thick = 2;
        Mat sv = svm.getUncompressedSupportVectors();
 float[] svData = new float[(int) (sv.total() * sv.channels())];
        sv.get(0, 0, svData);
 for (int i = 0; i < sv.rows(); i++) {
            Imgproc.circle(I, new Point(svData[i * sv.cols()], svData[i * sv.cols() + 1]), 6, new Scalar(128, 128, 128),
                    thick, lineType, 0);
        }

Python

thick = 2
sv = svm.getUncompressedSupportVectors()
 
for i in range(sv.shape[0]):
 cv.circle(I, (int(sv[i,0]), int(sv[i,1])), 6, (128, 128, 128), thick)

結果

• このコードは画像を開き、両クラスの訓練サンプルを表示する。一方のクラスの点は薄い緑で表され、もう一方のクラスには薄い青が使われる。
• SVMは訓練され、画像の全ピクセルを分類するために使われる。その結果、画像は青の領域と緑の領域に分割される。両領域の境界が分離超平面である。訓練データは線形分離できないため、両クラスのサンプルの一部が誤分類されているのがわかる。いくつかの緑の点が青の領域に、いくつかの青の点が緑の領域に位置している。
• 最後に、サポートベクトルが訓練サンプルの周囲のグレーのリングを用いて表示される。

この実行例は こちらのYouTube で確認できる。