使用Java调用Yolo模型的基本步骤
作者：轩Scott
一、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);
其中，labels是类别标签，0.6是阈值，0.4是NMS（非极大值抑制）的阈值。
6. 将以上代码封装成一个可执行软件.exe，可以使用Java打包工具，如Maven、Gradle等进行打包。
以上是使用DL4J调用yolo训练好的.pt模型的基本步骤，具体实现还需要根据实际情况进行调整和优化。
到此这篇关于使用Java调用Yolo模型的方法与步骤的文章就介绍到这了,更多相关Java调用Yolo模型内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！