How to perform machine learning tasks with OpenCV.js? - 面试题

OpenCV.js supports various machine learning algorithms. While not as powerful as dedicated machine learning libraries, it's sufficient for many computer vision tasks. Here are the machine learning capabilities available in OpenCV.js:

1. Machine Learning Algorithms Overview

Machine learning algorithms provided by OpenCV.js include:

K-Nearest Neighbors (KNN): For classification and regression
Support Vector Machine (SVM): For classification and regression
Decision Trees: For classification and regression
Random Forest: Ensemble learning method
Boosting: AdaBoost and other boosting algorithms
Neural Networks: Basic MLP neural networks

2. K-Nearest Neighbors (KNN) Classification

javascript
function knnClassification() {
  // Prepare training data
  let trainData = cv.matFromArray(6, 2, cv.CV_32FC1, [
    1.0, 1.1,
    1.0, 1.0,
    0.0, 0.0,
    0.0, 0.1,
    0.1, 0.0,
    0.1, 0.1
  ]);
  
  let labels = cv.matFromArray(6, 1, cv.CV_32SC1, [0, 0, 1, 1, 1, 1]);
  
  // Create KNN model
  let knn = new cv.ml.KNearest();
  knn.setDefaultK(3);
  knn.setIsClassifier(true);
  
  // Train model
  knn.train(trainData, cv.ml.ROW_SAMPLE, labels);
  
  // Predict new sample
  let newSample = cv.matFromArray(1, 2, cv.CV_32FC1, [0.5, 0.5]);
  let results = new cv.Mat();
  let neighbors = new cv.Mat();
  let dist = new cv.Mat();
  
  knn.findNearest(newSample, 3, results, neighbors, dist);
  
  console.log('Predicted class:', results.data32S[0]);
  
  // Cleanup
  trainData.delete();
  labels.delete();
  newSample.delete();
  results.delete();
  neighbors.delete();
  dist.delete();
  knn.clear();
}

3. Support Vector Machine (SVM)

javascript
function svmClassification() {
  // Prepare training data
  let trainData = cv.matFromArray(4, 2, cv.CV_32FC1, [
    1.0, 1.0,
    2.0, 2.0,
    -1.0, -1.0,
    -2.0, -2.0
  ]);
  
  let labels = cv.matFromArray(4, 1, cv.CV_32SC1, [1, 1, -1, -1]);
  
  // Create SVM model
  let svm = cv.ml.SVM.create();
  svm.setType(cv.ml.SVM_C_SVC);
  svm.setKernel(cv.ml.SVM_LINEAR);
  svm.setTermCriteria(new cv.TermCriteria(cv.TermCriteria_MAX_ITER, 100, 1e-6));
  
  // Train model
  svm.train(trainData, cv.ml.ROW_SAMPLE, labels);
  
  // Predict
  let testSample = cv.matFromArray(1, 2, cv.CV_32FC1, [1.5, 1.5]);
  let response = svm.predict(testSample);
  
  console.log('Predicted class:', response);
  
  // Cleanup
  trainData.delete();
  labels.delete();
  testSample.delete();
  svm.clear();
}

4. Decision Trees

javascript
function decisionTreeClassification() {
  // Prepare training data
  let trainData = cv.matFromArray(10, 2, cv.CV_32FC1, [
    1.0, 1.0,
    1.0, 2.0,
    2.0, 1.0,
    2.0, 2.0,
    3.0, 1.0,
    3.0, 2.0,
    1.0, 3.0,
    2.0, 3.0,
    3.0, 3.0,
    4.0, 3.0
  ]);
  
  let labels = cv.matFromArray(10, 1, cv.CV_32SC1, [0, 0, 0, 0, 0, 0, 1, 1, 1, 1]);
  
  // Create decision tree
  let dtree = cv.ml.DTrees.create();
  dtree.setMaxDepth(5);
  dtree.setMinSampleCount(2);
  dtree.setCVFolds(0);
  
  // Train
  dtree.train(trainData, cv.ml.ROW_SAMPLE, labels);
  
  // Predict
  let testSample = cv.matFromArray(1, 2, cv.CV_32FC1, [2.5, 2.5]);
  let response = dtree.predict(testSample);
  
  console.log('Predicted class:', response);
  
  // Cleanup
  trainData.delete();
  labels.delete();
  testSample.delete();
  dtree.clear();
}

5. Random Forest

javascript
function randomForestClassification() {
  // Prepare training data
  let trainData = cv.matFromArray(20, 2, cv.CV_32FC1, [
    // Class 0
    1.0, 1.0, 1.0, 2.0, 2.0, 1.0, 2.0, 2.0,
    1.5, 1.5, 1.5, 2.5, 2.5, 1.5, 2.5, 2.5,
    // Class 1
    4.0, 4.0, 4.0, 5.0, 5.0, 4.0, 5.0, 5.0,
    4.5, 4.5, 4.5, 5.5, 5.5, 4.5, 5.5, 5.5
  ]);
  
  let labels = cv.matFromArray(20, 1, cv.CV_32SC1, [
    0, 0, 0, 0, 0, 0, 0, 0,
    1, 1, 1, 1, 1, 1, 1, 1
  ]);
  
  // Create random forest
  let rf = cv.ml.RTrees.create();
  rf.setMaxDepth(10);
  rf.setMinSampleCount(2);
  rf.setActiveVarCount(0);
  rf.setTermCriteria(new cv.TermCriteria(cv.TermCriteria_MAX_ITER, 100, 0.01));
  
  // Train
  rf.train(trainData, cv.ml.ROW_SAMPLE, labels);
  
  // Predict
  let testSample = cv.matFromArray(1, 2, cv.CV_32FC1, [3.0, 3.0]);
  let response = rf.predict(testSample);
  
  console.log('Predicted class:', response);
  
  // Cleanup
  trainData.delete();
  labels.delete();
  testSample.delete();
  rf.clear();
}

6. AdaBoost

javascript
function adaboostClassification() {
  // Prepare training data
  let trainData = cv.matFromArray(10, 2, cv.CV_32FC1, [
    1.0, 1.0,
    1.0, 2.0,
    2.0, 1.0,
    2.0, 2.0,
    4.0, 4.0,
    4.0, 5.0,
    5.0, 4.0,
    5.0, 5.0,
    3.0, 3.0,
    3.5, 3.5
  ]);
  
  let labels = cv.matFromArray(10, 1, cv.CV_32SC1, [0, 0, 0, 0, 1, 1, 1, 1, 0, 0]);
  
  // Create AdaBoost
  let boost = cv.ml.Boost.create();
  boost.setBoostType(cv.ml.DISCRETE);
  boost.setWeakCount(100);
  boost.setWeightTrimRate(0.95);
  boost.setMaxDepth(2);
  
  // Train
  boost.train(trainData, cv.ml.ROW_SAMPLE, labels);
  
  // Predict
  let testSample = cv.matFromArray(1, 2, cv.CV_32FC1, [3.0, 3.0]);
  let response = boost.predict(testSample);
  
  console.log('Predicted class:', response);
  
  // Cleanup
  trainData.delete();
  labels.delete();
  testSample.delete();
  boost.clear();
}

7. Neural Networks (MLP)

javascript
function mlpClassification() {
  // Prepare training data (XOR problem)
  let trainData = cv.matFromArray(4, 2, cv.CV_32FC1, [
    0.0, 0.0,
    0.0, 1.0,
    1.0, 0.0,
    1.0, 1.0
  ]);
  
  let labels = cv.matFromArray(4, 1, cv.CV_32FC1, [0.0, 1.0, 1.0, 0.0]);
  
  // Create neural network
  let layers = new cv.Mat();
  layers.push_back(new cv.Scalar(2));  // Input layer: 2 neurons
  layers.push_back(new cv.Scalar(4));  // Hidden layer: 4 neurons
  layers.push_back(new cv.Scalar(1));  // Output layer: 1 neuron
  
  let mlp = cv.ml.ANN_MLP.create();
  mlp.setLayerSizes(layers);
  mlp.setActivationFunction(cv.ml.ANN_MLP_SIGMOID_SYM, 1, 1);
  mlp.setTrainMethod(cv.ml.ANN_MLP_BACKPROP);
  mlp.setBackpropWeightScale(0.1);
  mlp.setBackpropMomentumScale(0.1);
  mlp.setTermCriteria(new cv.TermCriteria(cv.TermCriteria_MAX_ITER + cv.TermCriteria_EPS, 10000, 1e-6));
  
  // Train
  mlp.train(trainData, cv.ml.ROW_SAMPLE, labels);
  
  // Predict
  let testSample = cv.matFromArray(1, 2, cv.CV_32FC1, [0.0, 1.0]);
  let response = new cv.Mat();
  mlp.predict(testSample, response);
  
  console.log('Predicted output:', response.data32F[0]);
  
  // Cleanup
  trainData.delete();
  labels.delete();
  testSample.delete();
  response.delete();
  layers.delete();
  mlp.clear();
}

8. Practical Application: Image Classification

javascript
class ImageClassifier {
  constructor() {
    this.model = null;
    this.featureExtractor = null;
  }
  
  // Extract image features
  extractFeatures(image) {
    let mat = cv.imread(image);
    let gray = new cv.Mat();
    let features = new cv.Mat();
    
    try {
      cv.cvtColor(mat, gray, cv.COLOR_RGBA2GRAY);
      
      // Calculate histogram as features
      let histSize = [16];
      let ranges = [0, 256];
      cv.calcHist([gray], [0], new cv.Mat(), features, histSize, ranges);
      
      // Normalize
      cv.normalize(features, features, 0, 1, cv.NORM_MINMAX);
      
      return features;
    } finally {
      mat.delete();
      gray.delete();
    }
  }
  
  // Train classifier
  async trainClassifier(imagePaths, labels) {
    let trainData = new cv.Mat();
    let trainLabels = new cv.Mat();
    
    for (let i = 0; i < imagePaths.length; i++) {
      const img = document.getElementById(imagePaths[i]);
      const features = this.extractFeatures(img);
      
      if (i === 0) {
        features.copyTo(trainData);
      } else {
        trainData.push_back(features);
      }
      
      trainLabels.push_back(labels[i]);
      features.delete();
    }
    
    // Use SVM classifier
    this.model = cv.ml.SVM.create();
    this.model.setType(cv.ml.SVM_C_SVC);
    this.model.setKernel(cv.ml.SVM_RBF);
    this.model.setC(1);
    this.model.setGamma(0.5);
    this.model.train(trainData, cv.ml.ROW_SAMPLE, trainLabels);
    
    trainData.delete();
    trainLabels.delete();
  }
  
  // Predict image class
  predict(image) {
    const features = this.extractFeatures(image);
    const response = this.model.predict(features);
    features.delete();
    return response;
  }
  
  // Cleanup
  cleanup() {
    if (this.model) {
      this.model.clear();
    }
  }
}

9. Performance Optimization Tips

Data Preprocessing: Normalize input data to improve training efficiency
Feature Selection: Choose most discriminative features
Model Selection: Choose appropriate algorithm based on data characteristics
Cross-validation: Use cross-validation to evaluate model performance
Hyperparameter Tuning: Adjust hyperparameters for optimal performance

Summary

The machine learning capabilities provided by OpenCV.js, while not as powerful as dedicated machine learning libraries (like TensorFlow.js), are sufficient for many traditional computer vision tasks. When choosing to use OpenCV.js machine learning features, consider:

Task Complexity: Simple classification tasks are suitable, complex deep learning tasks should use TensorFlow.js
Performance Requirements: Real-time tasks need optimized algorithms and data
Data Scale: Small datasets are suitable, large datasets suggest backend processing
Accuracy Requirements: High accuracy requirements may need more powerful machine learning frameworks