C#使用加载Yolov5-seg分割模型

已于 2024-05-20 16:44:33 修改
阅读量563 收藏 3
点赞数 3
文章标签： c# YOLO windows
于 2023-10-12 16:41:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49595983/article/details/133794163
版权
本文展示了如何使用OpenVinoSharp在Windows环境中结合yolov5模型进行物体检测，并对检测结果进行分割。代码实现了从图像读取、模型推理到非极大值抑制（NMS）的过程。
摘要由CSDN通过智能技术生成

使用OpenVinoSharp.win

using System;
using OpenCvSharp;
using OpenVinoSharp;
using OpenCvSharp.Dnn;
using System.IO;
using System.Collections.Generic;
namespace Yolov5Seg
{
    class Program
    {
        private static float sigmoid(float a)
        {
            float b = 1.0f / (1.0f + (float)Math.Exp(-a));
            return b;
        }
        public static string[] read_class_names(string path)
        {
            string[] class_names;
            List<string> str = new List<string>();
            StreamReader sr = new StreamReader(path);
            string line;
            while ((line = sr.ReadLine()) != null)
            {
                str.Add(line);
            }
            class_names = str.ToArray();
            return class_names;
        }
        static void Main(string[] args)
        {
            float[] det_result_array = new float[25200 * 117];
            float[] proto_result_array = new float[32 * 160 * 160];
            float conf_threshold = 0.25f;
            float nms_threshold = 0.5f;
            float[] factors = new float[4];
            List<Rect> position_boxes = new List<Rect>();
            List<int> class_ids = new List<int>();
            List<float> class_scores = new List<float>();
            List<float> confidences = new List<float>();
            List<Mat> masks = new List<Mat>();
            Mat masked_img = new Mat();
            string model_path = "yolov5n-seg.onnx";
            string image_path = "bus.jpg";
            Mat image = Cv2.ImRead(image_path);
            string[] classes_names = read_class_names("coco.names");
            int max_image_length = image.Cols > image.Rows ? image.Cols : image.Rows;
            factors[0] = factors[1] = (float)(max_image_length / 640.0);
            factors[2] = image.Rows;
            factors[3] = image.Cols;
            Mat max_image = Mat.Zeros(new OpenCvSharp.Size(max_image_length, max_image_length), MatType.CV_8UC3);
            Rect roi = new Rect(0, 0, image.Cols, image.Rows);
            image.CopyTo(new Mat(max_image, roi));
            factors[0] = factors[1] = (float)(max_image_length / 640.0);
            Core core = new Core(model_path, "CPU");
            byte[] image_data = max_image.ImEncode(".bmp");
            ulong image_size = Convert.ToUInt64(image_data.Length);
            core.load_input_data("images", image_data, image_size, 1);
            core.infer();
            det_result_array = core.read_infer_result<float>("output0", 25200 * 117);
            proto_result_array = core.read_infer_result<float>("output1", 32 * 160 * 160);
            core.delet();
            Mat detect_data = new Mat(25200, 117, MatType.CV_32F, det_result_array);
            Mat proto_data = new Mat(32, 25600, MatType.CV_32F, proto_result_array);
            for (int i = 0; i < detect_data.Rows; i++)
            {
                Mat conf_scores = detect_data.Row(i).ColRange(4, 5);
                float conf_value = conf_scores.Get<float>(0, 0);
                if (conf_value < conf_threshold)
                {
                    continue;
                }
                Mat classes_scores = detect_data.Row(i).ColRange(5, 85);//GetArray(i, 5, classes_scores);
                Point max_classId_point, min_classId_point;
                double max_score, min_score;
                Cv2.MinMaxLoc(classes_scores, out min_score, out max_score,
                    out min_classId_point, out max_classId_point);
                if (max_score > 0.25)
                {
                    Mat mask = detect_data.Row(i).ColRange(85, 117);
                    float cx = detect_data.At<float>(i, 0);
                    float cy = detect_data.At<float>(i, 1);
                    float ow = detect_data.At<float>(i, 2);
                    float oh = detect_data.At<float>(i, 3);
                    int x = (int)((cx - 0.5 * ow) * factors[0]);
                    int y = (int)((cy - 0.5 * oh) * factors[1]);
                    int width = (int)(ow * factors[0]);
                    int height = (int)(oh * factors[1]);
                    Rect box = new Rect();
                    box.X = x;
                    box.Y = y;
                    box.Width = width;
                    box.Height = height;
                    position_boxes.Add(box);
                    class_ids.Add(max_classId_point.X);
                    classes_scores.Add(max_score);
                    confidences.Add((float)max_score);
                    masks.Add(mask);
                }
            }
            int[] indexes = new int[position_boxes.Count];
            CvDnn.NMSBoxes(position_boxes, confidences, conf_threshold, nms_threshold, out indexes);
            Mat rgb_mask = Mat.Zeros(new Size((int)factors[3], (int)factors[2]), MatType.CV_8UC3);
            Random rd = new Random();
            for (int i = 0; i < indexes.Length; i++)
            {
                int index = indexes[i];
                Rect box = position_boxes[index];
                int box_x1 = Math.Max(0, box.X);
                int box_y1 = Math.Max(0, box.Y);
                int box_x2 = Math.Max(0, box.BottomRight.X);
                int box_y2 = Math.Max(0, box.BottomRight.Y);
                Mat original_mask = masks[index] * proto_data;
                for (int col = 0; col < original_mask.Cols; col++)
                {
                    original_mask.At<float>(0, col) = sigmoid(original_mask.At<float>(0, col));
                }
                Mat reshape_mask = original_mask.Reshape(1, 160);
                int mx1 = Math.Max(0, (int)((box_x1 / factors[0]) * 0.25));
                int mx2 = Math.Max(0, (int)((box_x2 / factors[0]) * 0.25));
                int my1 = Math.Max(0, (int)((box_y1 / factors[1]) * 0.25));
                int my2 = Math.Max(0, (int)((box_y2 / factors[1]) * 0.25));
                Mat mask_roi = new Mat(reshape_mask, new OpenCvSharp.Range(my1, my2), new OpenCvSharp.Range(mx1, mx2));
                Mat actual_maskm = new Mat();
                Cv2.Resize(mask_roi, actual_maskm, new Size(box_x2 - box_x1, box_y2 - box_y1));
                for (int r = 0; r < actual_maskm.Rows; r++)
                {
                    for (int c = 0; c < actual_maskm.Cols; c++)
                    {
                        float pv = actual_maskm.At<float>(r, c);
                        if (pv > 0.5)
                        {
                            actual_maskm.At<float>(r, c) = 1.0f;
                        }
                        else
                        {
                            actual_maskm.At<float>(r, c) = 0.0f;
                        }
                    }
                }
                Mat bin_mask = new Mat();
                actual_maskm = actual_maskm * 200;
                actual_maskm.ConvertTo(bin_mask, MatType.CV_8UC1);
                if ((box_y1 + bin_mask.Rows) >= factors[2])
                {
                    box_y2 = (int)factors[2] - 1;
                }
                if ((box_x1 + bin_mask.Cols) >= factors[3])
                {
                    box_x2 = (int)factors[3] - 1;
                }
                Mat mask = Mat.Zeros(new Size((int)factors[3], (int)factors[2]), MatType.CV_8UC1);
                bin_mask = new Mat(bin_mask, new OpenCvSharp.Range(0, box_y2 - box_y1), new OpenCvSharp.Range(0, box_x2 - box_x1));
                Rect rois = new Rect(box_x1, box_y1, box_x2 - box_x1, box_y2 - box_y1);
                bin_mask.CopyTo(new Mat(mask, rois));
                Cv2.Add(rgb_mask, new Scalar(rd.Next(0, 255), rd.Next(0, 255), rd.Next(0, 255)), rgb_mask, mask); 
                Cv2.Rectangle(image, position_boxes[index], new Scalar(0, 0, 255), 2, LineTypes.Link8);
                Cv2.Rectangle(image, new Point(position_boxes[index].TopLeft.X, position_boxes[index].TopLeft.Y - 20),
                    new Point(position_boxes[index].BottomRight.X, position_boxes[index].TopLeft.Y), new Scalar(0, 255, 255), -1);
                Cv2.PutText(image, classes_names[class_ids[index]] + "-" + confidences[index].ToString("0.00"),
                    new Point(position_boxes[index].X, position_boxes[index].Y - 10),
                    HersheyFonts.HersheySimplex, 0.6, new Scalar(0, 0, 0), 1);
                Cv2.AddWeighted(image, 0.5, rgb_mask.Clone(), 0.5, 0, masked_img);
            }
            Cv2.ImShow("Result", masked_img);
            Cv2.WaitKey(5000);
        }
    }
}

使用Microsoft.ML.OnnxRuntime

using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
using OpenCvSharp;
using OpenCvSharp.Dnn;
namespace Yolov5Seg
{
    class Program
    {
        private static float sigmoid(float a)
        {
            float b = 1.0f / (1.0f + (float)Math.Exp(-a));
            return b;
        }
        public static string[] read_class_names(string path)
        {
            string[] class_names;
            List<string> str = new List<string>();
            StreamReader sr = new StreamReader(path);
            string line;
            while ((line = sr.ReadLine()) != null)
            {
                str.Add(line);
            }
            class_names = str.ToArray();
            return class_names;
        }
        static void Main(string[] args)
        {
            float conf_threshold = 0.25f;
            float nms_threshold = 0.5f;
            string model_path = "yolov5n-seg.onnx";
            string image_path = "bus.jpg";
            string[] classes_names = read_class_names("coco.names");
            Mat masked_img = new Mat();
            List<NamedOnnxValue> input_ontainer;
            List<Rect> position_boxes = new List<Rect>();
            List<int> class_ids = new List<int>();
            List<float> class_scores = new List<float>();
            List<float> confidences = new List<float>();
            List<Mat> masks = new List<Mat>();
            Tensor<float> result_tensors_det;
            Tensor<float> result_tensors_proto;
            SessionOptions options;
            InferenceSession onnx_session;
            Tensor<float> input_tensor;
            IDisposableReadOnlyCollection<DisposableNamedOnnxValue> result_infer;
            DisposableNamedOnnxValue[] results_onnxvalue;
            options = new SessionOptions();
            options.LogSeverityLevel = OrtLoggingLevel.ORT_LOGGING_LEVEL_INFO;
            options.AppendExecutionProvider_CPU(0);
            onnx_session = new InferenceSession(model_path, options);
            input_ontainer = new List<NamedOnnxValue>();
            Mat image = Cv2.ImRead(image_path);
            int max_image_length = image.Cols > image.Rows ? image.Cols : image.Rows;
            Mat max_image = Mat.Zeros(new OpenCvSharp.Size(max_image_length, max_image_length), MatType.CV_8UC3);
            Rect roi = new Rect(0, 0, image.Cols, image.Rows);
            image.CopyTo(new Mat(max_image, roi));
            float[] det_result_array = new float[25200 * 117];
            float[] proto_result_array = new float[32 * 160 * 160];
            float[] factors = new float[4];
            factors[0] = factors[1] = (float)(max_image_length / 640.0);
            factors[2] = image.Rows;
            factors[3] = image.Cols;
            Mat image_rgb = new Mat();
            Mat resize_image = new Mat();
            Cv2.CvtColor(max_image, image_rgb, ColorConversionCodes.BGR2RGB);
            Cv2.Resize(image_rgb, resize_image, new OpenCvSharp.Size(640, 640));
            input_tensor = new DenseTensor<float>(new[] { 1, 3, 640, 640 });
            for (int y = 0; y < resize_image.Height; y++)
            {
                for (int x = 0; x < resize_image.Width; x++)
                {
                    input_tensor[0, 0, y, x] = resize_image.At<Vec3b>(y, x)[0] / 255f;
                    input_tensor[0, 1, y, x] = resize_image.At<Vec3b>(y, x)[1] / 255f;
                    input_tensor[0, 2, y, x] = resize_image.At<Vec3b>(y, x)[2] / 255f;
                }
            }
            input_ontainer.Add(NamedOnnxValue.CreateFromTensor("images", input_tensor));
            result_infer = onnx_session.Run(input_ontainer);
            results_onnxvalue = result_infer.ToArray();
            result_tensors_det = results_onnxvalue[0].AsTensor<float>();
            result_tensors_proto = results_onnxvalue[1].AsTensor<float>();
            det_result_array = result_tensors_det.ToArray();
            proto_result_array = result_tensors_proto.ToArray();
            Mat detect_data = new Mat(25200, 117, MatType.CV_32F, det_result_array);
            Mat proto_data = new Mat(32, 25600, MatType.CV_32F, proto_result_array);
            for (int i = 0; i < detect_data.Rows; i++)
            {
                Mat conf_scores = detect_data.Row(i).ColRange(4, 5);
                float conf_value = conf_scores.Get<float>(0, 0);
                if (conf_value < conf_threshold)
                {
                    continue;
                }
                Mat classes_scores = detect_data.Row(i).ColRange(5, 85);
                Point max_classId_point, min_classId_point;
                double max_score, min_score;
                Cv2.MinMaxLoc(classes_scores, out min_score, out max_score,
                    out min_classId_point, out max_classId_point);
                if (max_score > 0.25)
                {
                    Mat mask = detect_data.Row(i).ColRange(85, 117);
                    float cx = detect_data.At<float>(i, 0);
                    float cy = detect_data.At<float>(i, 1);
                    float ow = detect_data.At<float>(i, 2);
                    float oh = detect_data.At<float>(i, 3);
                    int x = (int)((cx - 0.5 * ow) * factors[0]);
                    int y = (int)((cy - 0.5 * oh) * factors[1]);
                    int width = (int)(ow * factors[0]);
                    int height = (int)(oh * factors[1]);
                    Rect box = new Rect();
                    box.X = x;
                    box.Y = y;
                    box.Width = width;
                    box.Height = height;
                    position_boxes.Add(box);
                    class_ids.Add(max_classId_point.X);
                    classes_scores.Add(max_score);
                    confidences.Add((float)max_score);
                    masks.Add(mask);
                }
            }
            int[] indexes = new int[position_boxes.Count];
            CvDnn.NMSBoxes(position_boxes, confidences, conf_threshold, nms_threshold, out indexes);
            Mat rgb_mask = Mat.Zeros(new Size((int)factors[3], (int)factors[2]), MatType.CV_8UC3);
            Random rd = new Random();
            for (int i = 0; i < indexes.Length; i++)
            {
                int index = indexes[i];
                Rect box = position_boxes[index];
                int box_x1 = Math.Max(0, box.X);
                int box_y1 = Math.Max(0, box.Y);
                int box_x2 = Math.Max(0, box.BottomRight.X);
                int box_y2 = Math.Max(0, box.BottomRight.Y);
                Mat original_mask = masks[index] * proto_data;
                for (int col = 0; col < original_mask.Cols; col++)
                {
                    original_mask.At<float>(0, col) = sigmoid(original_mask.At<float>(0, col));
                }
                Mat reshape_mask = original_mask.Reshape(1, 160);
                int mx1 = Math.Max(0, (int)((box_x1 / factors[0]) * 0.25));
                int mx2 = Math.Max(0, (int)((box_x2 / factors[0]) * 0.25));
                int my1 = Math.Max(0, (int)((box_y1 / factors[1]) * 0.25));
                int my2 = Math.Max(0, (int)((box_y2 / factors[1]) * 0.25));
                Mat mask_roi = new Mat(reshape_mask, new OpenCvSharp.Range(my1, my2), new OpenCvSharp.Range(mx1, mx2));
                Mat actual_maskm = new Mat();
                Cv2.Resize(mask_roi, actual_maskm, new Size(box_x2 - box_x1, box_y2 - box_y1));
                for (int r = 0; r < actual_maskm.Rows; r++)
                {
                    for (int c = 0; c < actual_maskm.Cols; c++)
                    {
                        float pv = actual_maskm.At<float>(r, c);
                        if (pv > 0.5)
                        {
                            actual_maskm.At<float>(r, c) = 1.0f;
                        }
                        else
                        {
                            actual_maskm.At<float>(r, c) = 0.0f;
                        }
                    }
                }
                Mat bin_mask = new Mat();
                actual_maskm = actual_maskm * 200;
                actual_maskm.ConvertTo(bin_mask, MatType.CV_8UC1);
                if ((box_y1 + bin_mask.Rows) >= factors[2])
                {
                    box_y2 = (int)factors[2] - 1;
                }
                if ((box_x1 + bin_mask.Cols) >= factors[3])
                {
                    box_x2 = (int)factors[3] - 1;
                }
                Mat mask = Mat.Zeros(new Size((int)factors[3], (int)factors[2]), MatType.CV_8UC1);
                bin_mask = new Mat(bin_mask, new OpenCvSharp.Range(0, box_y2 - box_y1), new OpenCvSharp.Range(0, box_x2 - box_x1));
                Rect rois = new Rect(box_x1, box_y1, box_x2 - box_x1, box_y2 - box_y1);
                bin_mask.CopyTo(new Mat(mask, rois));
                Cv2.Add(rgb_mask, new Scalar(rd.Next(0, 255), rd.Next(0, 255), rd.Next(0, 255)), rgb_mask, mask);
                Cv2.Rectangle(image, position_boxes[index], new Scalar(0, 0, 255), 2, LineTypes.Link8);
                Cv2.Rectangle(image, new Point(position_boxes[index].TopLeft.X, position_boxes[index].TopLeft.Y - 20),
                    new Point(position_boxes[index].BottomRight.X, position_boxes[index].TopLeft.Y), new Scalar(0, 255, 255), -1);
                Cv2.PutText(image, classes_names[class_ids[index]] + "-" + confidences[index].ToString("0.00"),
                    new Point(position_boxes[index].X, position_boxes[index].Y - 10),
                    HersheyFonts.HersheySimplex, 0.6, new Scalar(0, 0, 0), 1);
                Cv2.AddWeighted(image, 0.5, rgb_mask.Clone(), 0.5, 0, masked_img);
            }
            Cv2.ImShow("Result", masked_img);
            Cv2.WaitKey(5000);
        }
    }
}
朱永博
关注
C# OpenVINO Crack Seg 裂缝分割 裂缝检测 源码
02-29
C# OpenVINO Crack Seg 裂缝分割 裂缝检测 源码 博客地址：https://lw112190.blog.csdn.net/article/details/136376122
C# OpenVino Yolov8 Seg 源码
02-05
C# OpenVino Yolov8 Seg 源码 博客地址：https://lw112190.blog.csdn.net/article/details/136038410
[C#]winform部署yolov5-onnx模型
lwx666sl的博客
01-08 162
相较于前代模型，Yolov5在训练过程中采用了许多优化策略，如数据增强、学习率衰减、知识蒸馏等，进一步提高了模型的性能。此外，Yolov5还支持多任务学习（Multi-task Learning），可以在同一模型中同时进行目标检测、实例分割和关键点检测等任务，提高了模型的泛化能力。未来，随着深度学习技术的不断发展，相信会有更多优秀的目标检测算法涌现出来，推动计算机视觉领域的技术进步。特征金字塔网络：特征金字塔网络在骨干网络的基础上，进一步提取多尺度的特征信息，为后续的目标检测提供丰富的特征信息。
[C#]使用onnxruntime部署yolov11-onnx实例分割模型
最新发布
FL1623863129的博客
10-06 1242
因此，需要使用适当的图像处理库（如OpenCV或System.Drawing）来调整图像的大小、归一化像素值，并将其转换为模型所需的张量格式。因此，在实际部署时，需要参考YOLOv11的文档和ONNX Runtime的API文档来确保正确理解和处理模型的输出。在C#中使用ONNX Runtime部署YOLOv11-ONNX实例分割模型，涉及到模型的加载、数据预处理、模型推理和后处理几个关键步骤。解析模型的输出，提取有用的信息（如检测框的坐标、类别和实例分割掩码），并根据需要进行进一步的处理或可视化。
使用 C# 和 ONNX Runtime 加载和运行 ONNX 模型
baidu_31718835的博客
06-15 9380
今天突然有人和我说想要实现windows环境下c#调用tensorflow模型，我想着ONNX不是可以搞嘛，然后我翻了一下以前做的，没翻到，就查询了下资料，鼓捣出来了下面将介绍如何使用 C# 和 ONNX Runtime 库加载并运行 ONNX 模型。ONNX是啥我就不说了，留个链接。废话不说，show me code！在本篇博客中，我们展示了如何使用 C# 和 ONNX Runtime 库加载和运行 ONNX 模型。
C# Onnx 使用onnxruntime部署实时视频帧插值
CrazyFlyingBee的博客
02-27 935
C# Onnx 使用onnxruntime部署实时视频帧插值
[C#]使用onnxruntime部署Detic检测2万1千种类别的物体
FL1623863129的博客
01-02 1214
对于第二种数据，仅进行分类任务，仍然可以使用相同的分类器权重W。总的来说，Detic的使用图像分类数据集的方法为目标检测带来了更多的多样性和精确性，克服了数据限制带来的问题，降低了数据获取的成本，使得可以更轻松地训练更多种类的分类器，从而提高了检测器的性能和鲁棒性。Detic方法的创新之处在于，它利用了图像分类数据的丰富性，以更大的词汇表进行推理，从而增加了目标检测器对不同类别的敏感性和准确性。然而，Detic采用了图像分类的数据集，这使得它能够检测出更多样的类别，并提供更精确的结果。
[C#]使用onnxruntime部署yolov8-onnx实例分割模型
FL1623863129的博客
01-03 1525
不过 ultralytics 并没有直接将开源库命名为 YOLOv8，而是直接使用 ultralytics 这个词，原因是 ultralytics 将这个库定位为算法框架，而非某一个特定算法，一个主要特点是可扩展性。YOLOv8 是一个 SOTA 模型，它建立在以前 YOLO 版本的成功基础上，并引入了新的功能和改进，以进一步提升性能和灵活性。具体创新包括一个新的骨干网络、一个新的 Ancher-Free 检测头和一个新的损失函数，可以在从 CPU 到 GPU 的各种硬件平台上运行。
C# OnnxRuntime 图像去雨
寒冰屋的专栏
08-25 90
C# OnnxRuntime 图像去雨
C#使用onnxruntime部署LYT-Net轻量级低光图像增强.rar
06-13
C#使用onnxruntime部署LYT-Net轻量级低光图像增强.rar 博客地址：https://lw112190.blog.csdn.net/article/details/139651005
C#使用YOLOv5进行人体检测
04-29
C#使用YOLOv5进行人体检测
C#使用onnxruntime部署Detic 检测2万1千种类别的物体源码
01-02
​ 【测试环境】 vs2019 opencvsharp4.8.0 onnxruntime1.16.3 【视频演示】 bilibili.com/video/BV1yC4y1i7dm/ 【博客地址】 blog.csdn.net/FL1623863129/article/details/135334010 ​
C# Onnx 使用onnxruntime部署夜间雾霾图像的可见度增强 源码
02-21
C# Onnx 使用onnxruntime部署夜间雾霾图像的可见度增强 源码 博客地址：https://lw112190.blog.csdn.net/article/details/136215707
C# Onnx Yolov8 Seg 实例分割.rar exe程序
09-11
标题中的"C# Onnx Yolov8 Seg 实例分割.rar exe程序"指的是一个使用C#编程语言开发的程序，该程序结合了ONNX（Open Neural Network Exchange）模型和YOLOv8（You Only Look Once的第八个版本）算法，用于执行实例...
C# OpenVino Yolov8 Seg 源码.rar
02-06
标题 "C# OpenVino Yolov8 Seg 源码.rar" 提供的信息表明，这是一个使用C#语言实现的项目，它集成了OpenVINO工具包，并且针对YOLOv8模型进行了语义分割（Seg）的实现。OpenVINO全称为Open Visual Inference and ...
YOLOv8分割训练及分割半自动标注
qq_41920323的博客
12-09 1801
本文介绍yolov8-seg的训练、测试，及如何利用v8-seg来实现自己数据集的半自动标注。
c#使用onnxruntime调用yolo模型导出的onnx模型分割图片
weixin_46648511的博客
03-20 853
c#使用onnxruntime调用yolo导出的onnx模型
[C#]winform部署yolov5实例分割模型onnx
FL1623863129的博客
01-26 966
此外，它还可以处理多个物体在同一像素或同一位置的情况，这在一些场景中是非常有用的。总的来说，YOLOv5实例分割是一种非常有用的目标检测和分割算法，可以广泛应用于各种计算机视觉任务中。例如，它对于小物体的检测效果较差，因为小物体的特征比较微弱。在实例分割中，算法不仅要识别图像中的物体，还要对每个物体进行分割，以获得物体的精确边界。这需要对每个物体实例进行单独的预测，并使用像素级的掩膜来标记物体的边界。YOLOv5实例分割是目标检测算法的一个变种，主要用于识别和分割图像中的多个物体。
python加载yolov7-seg的模型和权重
07-13
要加载 YOLOv7-seg 的模型和权重，您可以使用以下代码： ```python import torch from models.experimental import attempt_load # 加载模型 model = attempt_load("yolov7-seg.pt", map_location=torch.device('cpu')) # 加载权重 weights = torch.load("yolov7-seg.weights", map_location=torch.device('cpu')) model.load_state_dict(weights['model']) ``` 请确保您已经安装了相关的依赖，并将模型文件 `yolov7-seg.pt` 和权重文件 `yolov7-seg.weights` 放在正确的路径下。上述代码假设您想在 CPU 上加载模型和权重，如果您想在 GPU 上运行，请将 `map_location` 参数修改为对应的设备。 请注意，这里的代码是基于 YOLOv7-seg 的官方实现。如果您使用的是其他版本或来源的 YOLOv7-seg 模型，可能需要做一些适应性调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值