OpenCV3 Java 机器学习使用方法汇总

最新推荐文章于 2024-09-01 22:34:14 发布
最新推荐文章于 2024-09-01 22:34:14 发布
阅读量2.1k 收藏 6
点赞数 3
分类专栏： OpenCV MLandPy

               原文链接：OpenCV3 Java 机器学习使用方法汇总                              

 前言

          按道理来说，C++版本的OpenCV训练的版本XML文件，在java中可以无缝使用。但要注意OpenCV本身的版本问题。从2.4 到3.x版本出现了很大的改变，XML文件本身的存储格式本身也不同，不能通用。


          opencv提供了非常多的机器学习算法用于研究。这里对这些算法进行分类学习和研究，以抛砖引玉。这里使用的机器学习算法包括：人工神经网络，boost,决策树，最近邻，逻辑回归，贝叶斯，随机森林，SVM等算法等。

          机器学习的过程相同，都要经历1、收集样本数据sampleData2.训练分类器mode3.对测试数据testData进行预测。这里使用一个在别处看到的例子，利用身高体重等原始信息预测男女的概率。通过一些简单的数据学习，用测试数据预测男女概率。

实例代码：

import org.opencv.core.Core;  
import org.opencv.core.CvType;  
import org.opencv.core.Mat;  
import org.opencv.core.TermCriteria;  
import org.opencv.ml.ANN_MLP;  
import org.opencv.ml.Boost;  
import org.opencv.ml.DTrees;  
import org.opencv.ml.KNearest;  
import org.opencv.ml.LogisticRegression;  
import org.opencv.ml.Ml;  
import org.opencv.ml.NormalBayesClassifier;  
import org.opencv.ml.RTrees;  
import org.opencv.ml.SVM;  
import org.opencv.ml.SVMSGD;  
import org.opencv.ml.TrainData;  
  
public class ML {  
    public static void main(String[] args) {  
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);  
        // 训练数据，两个维度，表示身高和体重  
        float[] trainingData = { 186, 80, 185, 81, 160, 50, 161, 48 };  
        // 训练标签数据，前两个表示男生0，后两个表示女生1,由于使用了多种机器学习算法，他们的输入有些不一样，所以labelsMat有三种   
        float[] labels = { 0f, 0f, 0f, 0f, 1f, 1f, 1f, 1f };  
        int[] labels2 = { 0, 0, 1, 1 };  
        float[] labels3 = { 0, 0, 1, 1 };  
        // 测试数据,先男后女  
        float[] test = { 184, 79, 159, 50 };  
  
        Mat trainingDataMat = new Mat(4, 2, CvType.CV_32FC1);  
        trainingDataMat.put(0, 0, trainingData);  
  
        Mat labelsMat = new Mat(4, 2, CvType.CV_32FC1);  
        labelsMat.put(0, 0, labels);  
  
        Mat labelsMat2 = new Mat(4, 1, CvType.CV_32SC1);  
        labelsMat2.put(0, 0, labels2);  
  
        Mat labelsMat3 = new Mat(4, 1, CvType.CV_32FC1);  
        labelsMat3.put(0, 0, labels3);  
  
        Mat sampleMat = new Mat(2, 2, CvType.CV_32FC1);  
        sampleMat.put(0, 0, test);  
  
        MyAnn(trainingDataMat, labelsMat, sampleMat);  
        MyBoost(trainingDataMat, labelsMat2, sampleMat);  
        MyDtrees(trainingDataMat, labelsMat2, sampleMat);  
        MyKnn(trainingDataMat, labelsMat3, sampleMat);  
        MyLogisticRegression(trainingDataMat, labelsMat3, sampleMat);  
        MyNormalBayes(trainingDataMat, labelsMat2, sampleMat);  
        MyRTrees(trainingDataMat, labelsMat2, sampleMat);  
        MySvm(trainingDataMat, labelsMat2, sampleMat);  
        MySvmsgd(trainingDataMat, labelsMat2, sampleMat);  
    }  
  
    // 人工神经网络  
    public static Mat MyAnn(Mat trainingData, Mat labels, Mat testData) {  
        // train data using aNN  
        TrainData td = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        Mat layerSizes = new Mat(1, 4, CvType.CV_32FC1);  
        // 含有两个隐含层的网络结构，输入、输出层各两个节点，每个隐含层含两个节点  
        layerSizes.put(0, 0, new float[] { 2, 2, 2, 2 });  
        ANN_MLP ann = ANN_MLP.create();  
        ann.setLayerSizes(layerSizes);  
        ann.setTrainMethod(ANN_MLP.BACKPROP);  
        ann.setBackpropWeightScale(0.1);  
        ann.setBackpropMomentumScale(0.1);  
        ann.setActivationFunction(ANN_MLP.SIGMOID_SYM, 1, 1);  
        ann.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER + TermCriteria.EPS, 300, 0.0));  
        boolean success = ann.train(td.getSamples(), Ml.ROW_SAMPLE, td.getResponses());  
        System.out.println("Ann training result: " + success);  
        // ann.save("D:/bp.xml");//存储模型  
        // ann.load("D:/bp.xml");//读取模型  
  
        // 测试数据  
        Mat responseMat = new Mat();  
        ann.predict(testData, responseMat, 0);  
        System.out.println("Ann responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.size().height; i++) {  
            if (responseMat.get(i, 0)[0] + responseMat.get(i, i)[0] >= 1)  
                System.out.println("Girl\n");  
            if (responseMat.get(i, 0)[0] + responseMat.get(i, i)[0] < 1)  
                System.out.println("Boy\n");  
        }  
        return responseMat;  
    }  
  
    // Boost  
    public static Mat MyBoost(Mat trainingData, Mat labels, Mat testData) {  
        Boost boost = Boost.create();  
        // boost.setBoostType(Boost.DISCRETE);  
        boost.setBoostType(Boost.GENTLE);  
        boost.setWeakCount(2);  
        boost.setWeightTrimRate(0.95);  
        boost.setMaxDepth(2);  
        boost.setUseSurrogates(false);  
        boost.setPriors(new Mat());  
  
        TrainData td = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        boolean success = boost.train(td.getSamples(), Ml.ROW_SAMPLE, td.getResponses());  
        System.out.println("Boost training result: " + success);  
        // boost.save("D:/bp.xml");//存储模型  
  
        Mat responseMat = new Mat();  
        float response = boost.predict(testData, responseMat, 0);  
        System.out.println("Boost responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.height(); i++) {  
            if (responseMat.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (responseMat.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
        return responseMat;  
    }  
  
    // 决策树  
    public static Mat MyDtrees(Mat trainingData, Mat labels, Mat testData) {  
        DTrees dtree = DTrees.create(); // 创建分类器  
        dtree.setMaxDepth(8); // 设置最大深度  
        dtree.setMinSampleCount(2);  
        dtree.setUseSurrogates(false);  
        dtree.setCVFolds(0); // 交叉验证  
        dtree.setUse1SERule(false);  
        dtree.setTruncatePrunedTree(false);  
  
        TrainData td = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        boolean success = dtree.train(td.getSamples(), Ml.ROW_SAMPLE, td.getResponses());  
        System.out.println("Dtrees training result: " + success);  
        // dtree.save("D:/bp.xml");//存储模型  
  
        Mat responseMat = new Mat();  
        float response = dtree.predict(testData, responseMat, 0);  
        System.out.println("Dtrees responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.height(); i++) {  
            if (responseMat.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (responseMat.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
        return responseMat;  
    }  
  
    // K最邻近  
    public static Mat MyKnn(Mat trainingData, Mat labels, Mat testData) {  
        final int K = 2;  
        TrainData td = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        KNearest knn = KNearest.create();  
        boolean success = knn.train(trainingData, Ml.ROW_SAMPLE, labels);  
        System.out.println("Knn training result: " + success);  
        // knn.save("D:/bp.xml");//存储模型  
  
        // find the nearest neighbours of test data  
        Mat results = new Mat();  
        Mat neighborResponses = new Mat();  
        Mat dists = new Mat();  
        knn.findNearest(testData, K, results, neighborResponses, dists);  
        System.out.println("results:\n" + results.dump());  
        System.out.println("Knn neighborResponses:\n" + neighborResponses.dump());  
        System.out.println("dists:\n" + dists.dump());  
        for (int i = 0; i < results.height(); i++) {  
            if (results.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (results.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
  
        return results;  
    }  
  
    // 逻辑回归  
    public static Mat MyLogisticRegression(Mat trainingData, Mat labels, Mat testData) {  
        LogisticRegression lr = LogisticRegression.create();  
  
        TrainData td = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        boolean success = lr.train(td.getSamples(), Ml.ROW_SAMPLE, td.getResponses());  
        System.out.println("LogisticRegression training result: " + success);  
        // lr.save("D:/bp.xml");//存储模型  
  
        Mat responseMat = new Mat();  
        float response = lr.predict(testData, responseMat, 0);  
        System.out.println("LogisticRegression responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.height(); i++) {  
            if (responseMat.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (responseMat.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
        return responseMat;  
    }  
  
    // 贝叶斯  
    public static Mat MyNormalBayes(Mat trainingData, Mat labels, Mat testData) {  
        NormalBayesClassifier nb = NormalBayesClassifier.create();  
  
        TrainData td = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        boolean success = nb.train(td.getSamples(), Ml.ROW_SAMPLE, td.getResponses());  
        System.out.println("NormalBayes training result: " + success);  
        // nb.save("D:/bp.xml");//存储模型  
  
        Mat responseMat = new Mat();  
        float response = nb.predict(testData, responseMat, 0);  
        System.out.println("NormalBayes responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.height(); i++) {  
            if (responseMat.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (responseMat.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
        return responseMat;  
    }  
  
    // 随机森林  
    public static Mat MyRTrees(Mat trainingData, Mat labels, Mat testData) {  
        RTrees rtrees = RTrees.create();  
        rtrees.setMaxDepth(4);  
        rtrees.setMinSampleCount(2);  
        rtrees.setRegressionAccuracy(0.f);  
        rtrees.setUseSurrogates(false);  
        rtrees.setMaxCategories(16);  
        rtrees.setPriors(new Mat());  
        rtrees.setCalculateVarImportance(false);  
        rtrees.setActiveVarCount(1);  
        rtrees.setTermCriteria(new TermCriteria(TermCriteria.MAX_ITER, 5, 0));  
        TrainData tData = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        boolean success = rtrees.train(tData.getSamples(), Ml.ROW_SAMPLE, tData.getResponses());  
        System.out.println("Rtrees training result: " + success);  
        // rtrees.save("D:/bp.xml");//存储模型  
  
        Mat responseMat = new Mat();  
        rtrees.predict(testData, responseMat, 0);  
        System.out.println("Rtrees responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.height(); i++) {  
            if (responseMat.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (responseMat.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
        return responseMat;  
    }  
  
    // 支持向量机  
    public static Mat MySvm(Mat trainingData, Mat labels, Mat testData) {  
        SVM svm = SVM.create();  
        svm.setKernel(SVM.LINEAR);  
        svm.setType(SVM.C_SVC);  
        TermCriteria criteria = new TermCriteria(TermCriteria.EPS + TermCriteria.MAX_ITER, 1000, 0);  
        svm.setTermCriteria(criteria);  
        svm.setGamma(0.5);  
        svm.setNu(0.5);  
        svm.setC(1);  
  
        TrainData td = TrainData.create(trainingData, Ml.ROW_SAMPLE, labels);  
        boolean success = svm.train(td.getSamples(), Ml.ROW_SAMPLE, td.getResponses());  
        System.out.println("Svm training result: " + success);  
        // svm.save("D:/bp.xml");//存储模型  
        // svm.load("D:/bp.xml");//读取模型  
  
        Mat responseMat = new Mat();  
        svm.predict(testData, responseMat, 0);  
        System.out.println("SVM responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.height(); i++) {  
            if (responseMat.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (responseMat.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
        return responseMat;  
    }  
  
    // SGD支持向量机  
    public static Mat MySvmsgd(Mat trainingData, Mat labels, Mat testData) {  
        SVMSGD Svmsgd = SVMSGD.create();  
        TermCriteria criteria = new TermCriteria(TermCriteria.EPS + TermCriteria.MAX_ITER, 1000, 0);  
        Svmsgd.setTermCriteria(criteria);  
        Svmsgd.setInitialStepSize(2);  
        Svmsgd.setSvmsgdType(SVMSGD.SGD);  
        Svmsgd.setMarginRegularization(0.5f);  
        boolean success = Svmsgd.train(trainingData, Ml.ROW_SAMPLE, labels);  
        System.out.println("SVMSGD training result: " + success);  
        // svm.save("D:/bp.xml");//存储模型  
        // svm.load("D:/bp.xml");//读取模型  
  
        Mat responseMat = new Mat();  
        Svmsgd.predict(testData, responseMat, 0);  
        System.out.println("SVMSGD responseMat:\n" + responseMat.dump());  
        for (int i = 0; i < responseMat.height(); i++) {  
            if (responseMat.get(i, 0)[0] == 0)  
                System.out.println("Boy\n");  
            if (responseMat.get(i, 0)[0] == 1)  
                System.out.println("Girl\n");  
        }  
        return responseMat;  
    }  
}

备注：作者的代码运行无误，可直接测试。



wishchin
关注
专栏目录
开源计算机视觉库OpenCV详解
dvlinker的技术专栏
06-23 8万+
详细介绍开源计算机视觉库OpenCV。
opencv3 编程入门学习笔记（一）： 基本函数介绍
weixin_30379531的博客
10-04 141
滤波 blur （均值滤波） 均值滤波是典型的线性滤波算法， 主要方法为领域平均法（即用一片图像区域的各个像素的平均值来代替原图像中的各个像素值） 缺点： 不能很好的保护图像细节， 在图像去噪的同时也破坏了图像的细节部分，从而使图像变得模糊。 函数原型： void blur(InputArray src, OutputArrary dst, Size ksize ， Point a...
Java中的深度学习：如何实现高效的卷积神经网络与循环神经网络
最新发布
微赚淘客系统开发者博客
09-01 1178
今天我们来探讨在Java中如何实现高效的深度学习模型，特别是卷积神经网络（CNN）和循环神经网络（RNN）。我们将使用Java的深度学习框架Deeplearning4j（DL4J）来实现这些模型，并讨论如何优化它们的性能。卷积神经网络（CNN）是一种专门用于处理图像数据的神经网络架构，能够自动提取图像的特征，并通过卷积层、池化层和全连接层的组合来实现对图像的分类和识别。循环神经网络（RNN）是一种适合处理序列数据的神经网络，能够捕捉时间序列中的时间依赖关系，非常适用于处理文本、时间序列数据等。
【Java版本OpenCV】无敌OpenCV越学越爽Java版代码持续更新（环境搭建|核心代码）
Java领域优秀创作者
03-11 6480
Java版本OpenCV代码实战,springboot整合opencv,包括linux,windows下opencv环境搭建,章节代码演示
OpenCV3.3-Java版的API文档（英文版）
12-15
OpenCV3.3-Java版的API文档（英文版），OpenCV-Java接口的API文档
OpenCV学习之路---JAVA
qiuxingcheng的博客
01-19 173
标题OpenCV给图片上logo 直接上代码 import org.junit.Test; import org.opencv.core.*; //import org.opencv.highgui.HighGui; import org.opencv.imgcodecs.Imgcodecs; import org.opencv.imgproc.Imgproc; /** *注意：1、代码中的路径需要自己配 * 2、this.saveImage(); 需要自己写，就一个保存代码。也可以使用HighGui
java 图像刺绣算法_图像处理：OpenCV3源代码文件解析
weixin_39622399的博客
02-01 347
引言结合冈萨雷斯的《数字图像处理》和Opencv3.0,学习图像处理算法有一段时间了，知道了函数怎么使用，但不知道opencv所用的函数源代码是如何编写的，“知其然，也要知其所以然”，闲暇之日，研究下源代码的编写，纵然不能全部看懂或者掌握，有收获就是好的。有诗为证，诗曰:图像处理有本质，二维数组是内涵。卷积频域来滤波，轮廓分割形态学。书山有路勤为径，兴趣使然来做舟。为识庐山真面目，学习源码实践多。...
100个精选、免费的、Java学习资源
热门推荐
gly1256288307的专栏
06-26 2万+
欢迎来到Java学习的精彩世界！这里有100个免费开源的Java学习资源和链接，为您提供全方位的学习支持和知识拓展。无论您是初学者还是有经验的开发者，这些资源将振奋您的学习激情，让您忍不住想深入浏览、探索，并充实自己的技能。这些资源涵盖了Java的方方面面，从基础知识到高级主题，从核心编程到框架应用，让您掌握Java编程的精髓；除此之外，资源还提供了JavaFX、JavaCV，Weka机器学习库、Java微服务框架等。这些资源能帮助您构建出色的用户界面、应用机器学习算法以及搭建可伸缩的分布式系统。无论您是自
11套opencv汇总手册及例程.rar
04-21
这个压缩包“11套opencv汇总手册及例程.rar”显然是一个集合，包含了多个OpenCV的学习资源，包括手册和实际的编程示例，旨在帮助用户深入理解和掌握OpenCV的使用。 OpenCV主要由C++编写，同时也提供了Python、Java...
C++开源计算机视觉库OpenCV详解
dvlinker的技术专栏
07-26 186
开源计算机视觉库OpenCV详解。
JAVA的OPENCV环境配置及学习案例
09-29
1、在Eclipse下配置基于Java的OpenCV开发环境； 2、用java来调用OpenCV； 3、CvArr、Mat、CvMat、IplImage、BYTE转换； 4、Java学习记录--OpenCV使用教程
libopencv_java3.so
09-07
libopencv_java3.so
opencv-java-tutorials：使用Java的OpenCV教程的源代码
02-05
opencv-java-tutorials：使用Java的OpenCV教程的源代码
OpenCV+Java+拍照+保存
02-25
在eclipse中配置好OpenCV后，利用Java调用OpenCV库函数实现本地摄像头的拍照功能并保存到本地。
OpenCV3.3-Java版的API文档
11-22
OpenCV-Java接口的API文档，里面是英文不是中文。但是不会影响阅读，到目前为止还没有中文的版的Java-opencv翻译版
java中的Opencv：Opencv简介与开发环境部署
qq_44849312的博客
08-26 2132
OpenCV （ Open Source Computer Vision Library ）是一个广泛应用于计算机视觉和图像处理领域的开源库。它提供了丰富的图像处理算法和工具，能够处理图像和视频数据，实现诸如特征提取、目标检测、图像分割等功能。OpenCV 是由 Intel 公司于 1999 年开发的开源计算机视觉库，旨在提供一套丰富的图像处理和计算机视觉算法。
OpenCV_java学习路线（1_入门第一个demo
qq_39909290的博客
10-21 402
opencv_java_eclipse/demo1 之前利用半学期时间入门了python-opencv的基本操作，并做了一个极其失败 的车牌识别程序。虽然不怎么成功，但也引起了我的学习兴趣，如今突然想起来这个东西，而且刚好在学习java，便想使用java复刻一个已经失败过一次 的 车牌识别。 用了一个下午的时间在搜索相关资料，最后悲哀的发现opencv-java的参考资料少得可怜，大多都是重...
Java机器学习库（OpenCV）（训练人脸识别级联分类器）
dbzzcz的博客
04-14 1751
样本 正样本 正样本是待检测的物体的图像。 正样本由opencv_createsamples工具生成。正样本可以由包含待检测物体的一张图片生成，也可由一系列标记好的图像生成。如果只有一张包含物体的图像，如一个公司的标志，那么可以通过对物体图像的随机旋转、改变标志亮度以及将标志放在任意的背景上而获得大量的正样本。生成的正样本数目以及随机的程度都可以通过 opencv_createsamples...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值