使用Java调用Yolo模型的方法与步骤

朴灿烈づ我的快乐病毒、 2024-03-22 17:29 33阅读 0赞

**目录**

一、Yolo模型简介

二、Java调用Yolo模型的方法

1. 安装OpenCV

2. 下载Yolo模型文件

3. 编写Java代码

三、Yolo模型的应用场景

1. 自动驾驶

2. 安防监控

3. 医疗诊断

4. 工业生产

四、总结

五、示例代码

七、DL4J

--------------------

## 一、Yolo模型简介 ##

Yolo（You Only Look Once）是一种基于深度学习的目标检测算法，它可以在一张图像中同时检测出多个目标，并给出它们的位置和类别。相比于传统的目标检测算法，Yolo算法具有检测速度快、精度高等优点，因此在实际应用中得到了广泛的应用。

## 二、Java调用Yolo模型的方法 ##

在Java中调用Yolo模型，需要使用OpenCV库。OpenCV是一个开源的计算机视觉库，它提供了各种各样的图像处理和计算机视觉算法，包括图像处理、特征提取、目标检测等。

下面我们将介绍如何使用Java调用Yolo模型。

### 1. 安装OpenCV ###

首先，我们需要安装OpenCV库。可以从OpenCV官网（https://opencv.org/）下载OpenCV的安装包，然后按照官方文档进行安装。

### 2. 下载Yolo模型文件 ###

接下来，我们需要下载Yolo模型文件。可以从Yolo官网（https://pjreddie.com/darknet/yolo/）下载预训练的Yolo模型文件，包括权重文件和配置文件。这些文件将用于检测图像中的目标。

下面是从Yolo官网下载预训练模型文件的详细步骤：

1. 打开Yolo官网（https://pjreddie.com/darknet/yolo/）。

2. 点击页面上方的“Download”按钮。

3. 在下载页面中，找到“Pre-trained Models”部分。

4. 在“Pre-trained Models”部分中，选择你需要下载的模型文件。例如，如果你需要下载YOLOv3模型文件，可以点击“YOLOv3”链接。

5. 在YOLOv3模型文件下载页面中，你会看到两个链接：一个是“yolov3.weights”，另一个是“yolov3-tiny.weights”。这两个链接分别对应YOLOv3和YOLOv3-tiny模型文件。

6. 点击你需要下载的模型文件链接，浏览器会自动开始下载。

7. 下载完成后，你可以将模型文件保存在你的本地计算机上，以备后续使用。

注意事项：

1. 下载模型文件可能需要一定的时间，具体时间取决于你的网络速度和文件大小。

2. 下载的模型文件是二进制文件，不能直接查看或编辑。如果需要使用模型文件，你需要使用相应的深度学习框架（如TensorFlow、PyTorch等）加载模型文件，并进行预测或训练等操作。

3. YOLOv3和YOLOv3-tiny模型文件的区别在于模型大小和精度。YOLOv3模型文件更大，但精度更高；YOLOv3-tiny模型文件更小，但精度较低。根据你的需求选择合适的模型文件。

### 3. 编写Java代码 ###

在安装好OpenCV库和下载好Yolo模型文件之后，我们就可以开始编写Java代码了。

首先，我们需要加载Yolo模型文件。可以使用OpenCV提供的Dnn模块来加载模型文件。具体代码如下：

String modelConfiguration = "path/to/yolov3.cfg";
    String modelWeights = "path/to/yolov3.weights";
    Net net = Dnn.readNetFromDarknet(modelConfiguration, modelWeights);

其中，modelConfiguration是Yolo模型的配置文件路径，modelWeights是Yolo模型的权重文件路径。Net是OpenCV中的一个类，它表示一个神经网络模型。

接下来，我们需要读取图像并进行目标检测。可以使用OpenCV提供的Imgcodecs模块来读取图像，使用Dnn模块来进行目标检测。具体代码如下：

String imagePath = "path/to/image.jpg";
    Mat image = Imgcodecs.imread(imagePath);
    Mat blob = Dnn.blobFromImage(image, 1/255.0, new Size(416, 416), new Scalar(0,0,0), true, false);
    net.setInput(blob);
    List<Mat> outputs = new ArrayList<>();
    List<String> outNames = net.getUnconnectedOutLayersNames();
    net.forward(outputs, outNames);

其中，imagePath是待检测的图像路径，image是读取的图像。blobFromImage方法将图像转换为神经网络的输入格式。Size表示输入图像的大小，Scalar表示输入图像的均值。net.setInput方法将输入数据设置为神经网络的输入。getUnconnectedOutLayersNames方法获取神经网络的输出层名称。forward方法将输入数据传递给神经网络，并获取输出结果。

最后，我们需要解析输出结果并绘制检测框。具体代码如下：

float confThreshold = 0.5f;
    List<Integer> classIds = new ArrayList<>();
    List<Float> confidences = new ArrayList<>();
    List<Rect> boxes = new ArrayList<>();
    for (int i = 0; i < outputs.size(); ++i) {
        Mat output = outputs.get(i);
        for (int j = 0; j < output.rows(); ++j) {
            Mat row = output.row(j);
            Mat scores = row.colRange(5, output.cols());
            Core.MinMaxLocResult mm = Core.minMaxLoc(scores);
            float confidence = (float) mm.maxVal;
            Point classIdPoint = mm.maxLoc;
            if (confidence > confThreshold) {
                int centerX = (int) (row.get(0, 0)[0] * image.cols());
                int centerY = (int) (row.get(0, 1)[0] * image.rows());
                int width = (int) (row.get(0, 2)[0] * image.cols());
                int height = (int) (row.get(0, 3)[0] * image.rows());
                int left = centerX - width / 2;
                int top = centerY - height / 2;
                classIds.add((int) classIdPoint.x);
                confidences.add(confidence);
                boxes.add(new Rect(left, top, width, height));
            }
        }
    }
    Mat labels = new Mat();
    MatOfFloat confidencesMat = new MatOfFloat(Converters.vector_float_to_Mat(confidences));
    MatOfInt indices = new MatOfInt();
    Dnn.NMSBoxes(boxes, confidencesMat, confThreshold, 0.4f, indices);
    for (int i = 0; i < indices.total(); ++i) {
        int idx = (int) indices.get(i, 0)[0];
        Rect box = boxes.get(idx);
        Imgproc.rectangle(image, box.tl(), box.br(), new Scalar(0, 255, 0), 2);
    }

其中，confThreshold是置信度阈值，classIds表示检测到的目标类别，confidences表示检测到的目标置信度，boxes表示检测到的目标框。MinMaxLocResult表示最大值和最小值的位置和值。NMSBoxes方法对检测框进行非极大值抑制，去除重叠的框。

我们可以将检测结果保存到文件或显示在屏幕上。具体代码如下：

String outputImagePath = "path/to/output/image.jpg";
    Imgcodecs.imwrite(outputImagePath, image);

## 三、Yolo模型的应用场景 ##

Yolo模型是一种高效的目标检测算法，因此在许多领域都有广泛的应用。以下是一些常见的应用场景：

### 1. 自动驾驶 ###

自动驾驶是Yolo模型的一个重要应用场景。通过使用Yolo模型，自动驾驶汽车可以实时检测道路上的车辆、行人、交通标志等物体，从而更好地控制车辆的行驶。

### 2. 安防监控 ###

在安防监控领域，Yolo模型可以用于实时检测和跟踪人员、车辆等物体，从而提高监控系统的效率和准确性。例如，在商场、银行等公共场所，Yolo模型可以用于检测和跟踪可疑人员，从而提高安全性。

### 3. 医疗诊断 ###

在医疗诊断领域，Yolo模型可以用于检测和识别医学图像中的病变和异常，从而帮助医生更准确地诊断疾病。例如，在CT扫描和X光检查中，Yolo模型可以用于检测和识别肿瘤、结节等异常。

### 4. 工业生产 ###

在工业生产领域，Yolo模型可以用于检测和识别生产线上的物体，从而提高生产效率和质量。例如，在电子工厂中，Yolo模型可以用于检测和识别电子元器件，从而提高生产线的效率和准确性。

## 四、总结 ##

Yolo模型是一种高效的目标检测算法，具有快速、准确、实时等优点。通过使用Java调用Yolo模型，我们可以在Java应用程序中实现目标检测功能，从而满足各种应用场景的需求。在未来，随着人工智能技术的不断发展，Yolo模型将在更多领域得到广泛应用，为人们的生活和工作带来更多的便利和效益。

## 五、示例代码 ##

以下是一个使用Java调用YOLO进行目标检测的示例代码：

import org.bytedeco.javacpp.Loader;
    import org.bytedeco.opencv.global.opencv_core;
    import org.bytedeco.opencv.opencv_core.*;
    import org.bytedeco.opencv.opencv_dnn.Net;
    import org.bytedeco.opencv.opencv_dnn.Net.LayerId;
    import org.bytedeco.opencv.opencv_dnn.Size;
    import org.bytedeco.opencv.opencv_imgcodecs.Imgcodecs;
    import org.bytedeco.opencv.opencv_imgproc.Imgproc;
    
    import java.io.File;
    import java.io.IOException;
    import java.nio.file.Files;
    import java.nio.file.Path;
    import java.nio.file.Paths;
    import java.util.ArrayList;
    import java.util.List;
    
    public class YoloDetector {
    
        private static final String MODEL_PATH = "yolov3.weights";
        private static final String CONFIG_PATH = "yolov3.cfg";
        private static final String[] CLASSES = {"person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "sofa", "pottedplant", "bed", "diningtable", "toilet", "tvmonitor", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"};
    
        public static void main(String[] args) {
            // Load the OpenCV and YOLO libraries
            Loader.load(org.bytedeco.opencv.global.opencv_core.class);
            Loader.load(org.bytedeco.opencv.global.opencv_imgproc.class);
            Loader.load(org.bytedeco.opencv.global.opencv_imgcodecs.class);
            Loader.load(org.bytedeco.opencv.global.opencv_dnn.class);
    
            // Load the YOLO model
            Net net = loadModel();
    
            // Load the input image
            Mat image = Imgcodecs.imread("input.jpg");
    
            // Perform object detection
            List<Mat> detections = detectObjects(net, image);
    
            // Draw bounding boxes around the detected objects
            drawBoundingBoxes(image, detections);
    
            // Save the output image
            Imgcodecs.imwrite("output.jpg", image);
        }
    
        private static Net loadModel() {
            // Load the model and configuration files
            File modelFile = new File(MODEL_PATH);
            File configFile = new File(CONFIG_PATH);
    
            // Create a new network from the model and configuration files
            Net net = new Net();
            net.readFromDarknet(configFile.getAbsolutePath(), modelFile.getAbsolutePath());
    
            // Set the backend and target to use OpenCV
            net.setPreferableBackend(org.bytedeco.opencv.global.opencv_dnn.DNN_BACKEND_OPENCV);
            net.setPreferableTarget(org.bytedeco.opencv.global.opencv_dnn.DNN_TARGET_CPU);
    
            return net;
        }
    
        private static List<Mat> detectObjects(Net net, Mat image) {
            // Create a blob from the input image
            Mat blob = org.bytedeco.opencv.global.opencv_dnn.blobFromImage(image, 1 / 255.0, new Size(416, 416), new Scalar(0, 0, 0), true, false);
    
            // Set the input to the network
            net.setInput(blob);
    
            // Get the output layers of the network
            List<LayerId> outLayers = new ArrayList<>();
            outLayers.add(new LayerId(net.getLayerId("yolo_82")));
            outLayers.add(new LayerId(net.getLayerId("yolo_94")));
            outLayers.add(new LayerId(net.getLayerId("yolo_106")));
    
            // Perform forward pass through the network
            List<Mat> detections = new ArrayList<>();
            net.forward(detections, outLayers);
    
            return detections;
        }
    
        private static void drawBoundingBoxes(Mat image, List<Mat> detections) {
            // Loop over the detections
            for (Mat detection : detections) {
                // Loop over the rows of the detection
                for (int i = 0; i < detection.rows(); i++) {
                    // Get the confidence and class ID of the detection
                    float[] data = new float[5];
                    detection.get(i, 0, data);
                    float confidence = data[4];
                    int classId = (int) data[1];
    
                    // Filter out weak detections
                    if (confidence > 0.5) {
                        // Get the bounding box coordinates
                        int centerX = (int) (data[0] * image.cols());
                        int centerY = (int) (data[1] * image.rows());
                        int width = (int) (data[2] * image.cols());
                        int height = (int) (data[3] * image.rows());
                        int left = centerX - width / 2;
                        int top = centerY - height / 2;
    
                        // Draw the bounding box
                        Rect rect = new Rect(left, top, width, height);
                        Imgproc.rectangle(image, rect, new Scalar(0, 255, 0), 2);
    
                        // Draw the class label
                        String label = CLASSES[classId];
                        int[] baseLine = new int[1];
                        Size labelSize = Imgproc.getTextSize(label, Imgproc.FONT_HERSHEY_SIMPLEX, 0.5, 1, baseLine);
                        Imgproc.rectangle(image, new Point(left, top - labelSize.height - 5), new Point(left + labelSize.width, top), new Scalar(0, 255, 0), -1);
                        Imgproc.putText(image, label, new Point(left, top - 5), Imgproc.FONT_HERSHEY_SIMPLEX, 0.5, new Scalar(255, 255, 255), 1);
                    }
                }
            }
        }
    }

这段代码使用了OpenCV和YOLO，可以在本地读取一张图片，调用YOLO进行目标检测，并将检测结果保存到本地。请注意，您需要下载YOLO的权重文件和配置文件，并将它们放在与代码相同的目录下。

## 七、DL4J ##

要使用Java调用yolo训练好的.pt模型，需要使用Java深度学习框架，如DL4J、Deeplearning4j等。这里以DL4J为例，介绍如何使用Java调用yolo训练好的.pt模型，并设计封装成一个可执行软件.exe。

1. 下载yolo的.pt模型和对应的配置文件，可以从yolo官网下载或者使用其他开源项目提供的模型和配置文件。

2. 安装DL4J，可以从DL4J官网下载或者使用Maven进行安装。

3. 使用DL4J加载yolo的.pt模型和配置文件，可以使用以下代码：

Yolo2Model yoloModel = new Yolo2Model();
    yoloModel.initTiny();
    ComputationGraph computationGraph = (ComputationGraph) yoloModel.getModel();

4. 使用DL4J对图像进行预测，可以使用以下代码：

INDArray input = Nd4j.create(imageData);
    INDArray[] output = computationGraph.output(input);

其中，imageData是输入图像的数据，output是输出的预测结果。

5. 将预测结果进行解析，可以使用以下代码：

YoloUtils.getPredictedObjects(labels, output, 0.6, 0.4);