PP-YOLO模型

最新推荐文章于 2024-06-27 15:34:17 发布
最新推荐文章于 2024-06-27 15:34:17 发布
阅读量289 收藏 4
点赞数 10
文章标签： YOLO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76950070/article/details/139935110
版权

PP-YOLO模型-行人检测系统


这里用到的模型链接是 添加链接描述
下载好模型放入文件夹，在克隆模型库
在这里插入图片描述

设置配置文件

crop_thresh: 0.5
attr_thresh: 0.5
kpt_thresh: 0.2
visual: True
warmup_frame: 50

DET:
  model_dir: ./mot_ppyoloe_l_36e_pipeline
  batch_size: 1

MOT:
  model_dir: ./mot_ppyoloe_l_36e_pipeline
  tracker_config: deploy/pipeline/config/tracker_config.yml
  batch_size: 1
  skip_frame_num: -1 # preferably no more than 3
  enable: True

KPT:
  model_dir: https://bj.bcebos.com/v1/paddledet/models/pipeline/dark_hrnet_w32_256x192.zip
  batch_size: 8

ATTR:
  model_dir:  ./output_inference/PPHGNet_small_person
  batch_size: 8
  enable: True

VIDEO_ACTION:
  model_dir: https://videotag.bj.bcebos.com/PaddleVideo-release2.3/ppTSM_fight.zip
  batch_size: 1
  frame_len: 8
  sample_freq: 7
  short_size: 340
  target_size: 320
  enable: False

SKELETON_ACTION:
  model_dir: https://bj.bcebos.com/v1/paddledet/models/pipeline/STGCN.zip
  batch_size: 1
  max_frames: 50
  display_frames: 80
  coord_size: [384, 512]
  enable: False

ID_BASED_DETACTION:
  model_dir:  https://bj.bcebos.com/v1/paddledet/models/pipeline/ppyoloe_crn_s_80e_smoking_visdrone.zip
  batch_size: 8
  threshold: 0.6
  display_frames: 80
  skip_frame_num: 2
  enable: False

ID_BASED_CLSACTION:
  model_dir: https://bj.bcebos.com/v1/paddledet/models/pipeline/PPHGNet_tiny_calling_halfbody.zip
  batch_size: 8
  threshold: 0.8
  display_frames: 80
  skip_frame_num: 2
  enable: False

REID:
  model_dir:  https://bj.bcebos.com/v1/paddledet/models/pipeline/reid_model.zip
  batch_size: 16
  enable: False

GUI界面设计

import torch.nn as nn
import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk,ImageDraw,ImageFont
import torch
from torchvision import transforms, models
from efficientnet_pytorch import EfficientNet
import numpy as np
import cv2
import tkinter.ttk as ttk
import time
from tkinter import filedialog
import subprocess
import os
import re
import threading

window = tk.Tk()
window.title("图像目标检测系统")
window.geometry('1400x700')  # 设置窗口大小
selected_image_path = None
label_text = None
right_canvas_image = None
progress = None
def upload_image():
    global selected_image_path, label_text,progress
    file_path = filedialog.askopenfilename()
    if file_path:
        selected_image_path = file_path
        image = Image.open(file_path)

        # 调整图片大小为500x400
        image = image.resize((500, 400), Image.Resampling.LANCZOS)

        # 居中图片
        photo = ImageTk.PhotoImage(image)
        canvas_left.create_image(0, 0, anchor='nw', image=photo)
        canvas_left.image = photo  # Keep a reference!

        # 创建进度条


def process_image2():
    global progress, label_text
    if selected_image_path is None:
        messagebox.showwarning("警告", "请先上传图片")
        return
    progress = ttk.Progressbar(window, orient='horizontal', length=160, mode='determinate', maximum=100)
    progress.place(x=1000, y=160)
    label_text = tk.Label(window, text="等待处理")  # 创建一个Label组件
    label_text.place(x=1200, y=160)  # 将Label组件添加到窗口中

    # 更新标签文本
    label_text.config(text="处理中...")
    # 模拟多车辆框选处理
    steps = 4  # 假设有3个处理步骤
    for i in range(steps):
        time.sleep(1)  # 每个步骤耗时1秒
        progress['value'] += 33.33  # 每个步骤增加33.33%的进度
        window.update_idletasks()  # 更新进度条显示

    # 构建命令行参数
    command = [
        "python",
        r"./deploy/pipeline/pipeline.py",  # 使用绝对路径
        "--config",
        r".\mot_ppyoloe_l_36e_pipeline\infer_cfg_pphuman.yml",  # 使用绝对路径
        "--image_file",
        selected_image_path
    ]

    # 使用subprocess.run()执行命令
    # capture_output=True captures the stdout and stderr, text=True decodes the output using the default encoding
    # We will handle the decoding manually to avoid the UnicodeDecodeError
    result = subprocess.run(command, capture_output=True, text=False)

    # Decode the stdout and stderr using 'utf-8'
    try:
        stdout = result.stdout.decode('utf-8')
        stderr = result.stderr.decode('utf-8')
    except UnicodeDecodeError:
        # If 'utf-8' decoding fails, try 'gbk' as a fallback
        stdout = result.stdout.decode('gbk')
        stderr = result.stderr.decode('gbk')

    print(stdout)
    print(stderr)

    output_folder_path = r'.\output'
    # 获取输出文件夹中的所有图片文件
    images = [f for f in os.listdir(output_folder_path) if f.endswith(('.png', '.jpg', '.jpeg', '.webp'))]

    # 获取每个图片文件的修改时间
    image_times = [(os.path.getmtime(os.path.join(output_folder_path, f)), f) for f in images]

    # 按修改时间排序，找到最新的图片
    latest_image_time, latest_image_name = max(image_times)
    latest_image_path = os.path.join(output_folder_path, latest_image_name)

    # 打开并显示最新的图片
    detection_image = Image.open(latest_image_path)
    detection_image = detection_image.resize((500, 400), Image.Resampling.LANCZOS)
    detection_photo = ImageTk.PhotoImage(detection_image)
    canvas_right.create_image(0, 0, anchor='nw', image=detection_photo)
    canvas_right.image = detection_photo  # 保持引用

    # 停止进度条
    progress.stop()
    progress.grid_forget()  # 隐藏进度条

    # 更新处理中标签
    label_text.config(text="处理完成")

    # 其他处理逻辑...

def video_detection_main():
    # 在新线程中运行EfficientNet_uI_main.py脚本
    def run_script():
        subprocess.run(['python', 'vido_detection2.py'])

    threading.Thread(target=run_script).start()

    # 等待子进程启动后立即销毁主窗口
    window.destroy()
# 创建主窗口

def Fall_detection():
    # 在新线程中运行EfficientNet_uI_main.py脚本
    def run_script():
        subprocess.run(['python', 'vido_detection3.py'])

    threading.Thread(target=run_script).start()

    # 等待子进程启动后立即销毁主窗口
    window.destroy()

# 创建背景画布并使用grid布局管理器
canvas_background = tk.Canvas(window, width=1400, height=700)
canvas_background.grid(row=0, column=0, columnspan=2, rowspan=4, sticky='nsew')  # 使用grid管理器


# 打开图片
image = Image.open(r"img\9.jpg")
# image = image.resize(1400, 700)
# 转换图像模式为RGB
image = image.convert("RGB")
draw = ImageDraw.Draw(image)
# 定义要画的文字和位置
text = "待检测的图片："
position = (440, 190)  # 文字的左上角位置坐标
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 30)  # 使用字体，字号30
# 画文字
draw.text(position, text, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

text2 = "检测结果："
position = (1180, 190)  # 文字的左上角位置坐标
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 30)  # 使用字体，字号30
# 画文字
draw.text(position, text2, fill=(0, 0, 0), font=font)  # fill参数为文字颜色



text3 = "基于深度学习的行人检测系统"
position = (580, 10)  # 文字的左上角位置坐标
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 50)  # 使用字体，字号30
# 画文字
draw.text(position, text3, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

text4 = "功能区"
position = (130, 200)
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 30)  # 使用字体，字号30
# 画文字
draw.text(position, text4, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

draw.line((30, 220, 120, 220), fill='black',width=3)
draw.line((30, 220, 30, 730), fill='black',width=3)
draw.line((30, 730, 320, 730), fill='black',width=3)
draw.line((320, 730, 320, 220), fill='black',width=3)
draw.line((320, 220, 230, 220), fill='black',width=3)
# 加载背景图像
background_image = image
background_image = background_image.resize((1400, 700), Image.Resampling.LANCZOS)  # 调整图像大小以适应窗口
background_photo = ImageTk.PhotoImage(background_image)

# 在背景画布上绘制背景图像
canvas_background.create_image(0, 0, anchor='nw', image=background_photo)
canvas_background.image = background_photo  # 保持对图像的引用

# 创建两个画布区域
canvas_left = tk.Canvas(window, width=500, height=400, bg="#e6f2ff")
canvas_right = tk.Canvas(window, width=500, height=400, bg="#e6f2ff")

# 将两个画布区域放置在主窗口中
canvas_left.place(x=325, y=200)
canvas_right.place(x=865, y=200)



# 创建按钮并放置在主窗口上
button_upload = tk.Button(window, width=13, text='上传图片', font=14, command=upload_image)
button_start_detection = tk.Button(window, width=13, text='行人检测', font=14, command=process_image2)



# 将按钮放置在主窗口上
button_upload.place(x=70, y=220)
button_start_detection.place(x=70, y=280)

#检测按钮
video_detection_main_button = tk.Button(window, width=13,text="视频检测",font=14, command=video_detection_main)
video_detection_main_button.place(x=70, y=340)
video_Fall_detection_button = tk.Button(window, width=13,text="摔倒检测",font=14, command=Fall_detection)
video_Fall_detection_button.place(x=70, y=400)
# 运行主窗口
window.mainloop()

在这里插入图片描述

行人图片检测

在这里插入图片描述

行人视频检测

import torch.nn as nn
import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk,ImageDraw,ImageFont
import torch
from torchvision import transforms, models
from efficientnet_pytorch import EfficientNet
import numpy as np
import cv2
import tkinter.ttk as ttk
import time
from tkinter import filedialog
import subprocess
import os
import re
import threading
import tkinter.messagebox as tkMessageBox
selected_video_path = None
label_text = None
cap = None
video_playing = False
# 创建主窗口
window = tk.Tk()
window.title("图像目标检测系统")
window.geometry('1400x700')  # 设置窗口大小

# 创建背景画布并使用grid布局管理器
canvas_background = tk.Canvas(window, width=1400, height=700)
canvas_background.grid(row=0, column=0, columnspan=2, rowspan=4, sticky='nsew')  # 使用grid管理器

# 打开图片
image = Image.open(r"img\9.jpg")
# 转换图像模式为RGB
image = image.convert("RGB")
draw = ImageDraw.Draw(image)
# 定义要画的文字和位置
text = "待检测的视频："
position = (440, 190)  # 文字的左上角位置坐标
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 30)  # 使用字体，字号30
# 画文字
draw.text(position, text, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

text2 = "检测结果："
position = (1180, 190)  # 文字的左上角位置坐标
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 30)  # 使用字体，字号30
# 画文字
draw.text(position, text2, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

# 定义要画的文字和位置
text = "待检测的视频："
position = (300, 50)  # 文字的左上角位置坐标
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 30)  # 使用字体，字号30
# 画文字
draw.text(position, text, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

text3 = "基于深度学习的行人检测系统"
position = (580, 10)  # 文字的左上角位置坐标
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 50)  # 使用字体，字号30
# 画文字
draw.text(position, text3, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

text4 = "功能区"
position = (100, 135)
# 定义字体和字号
font = ImageFont.truetype("SourceHanSansSC-Bold.otf", 30)  # 使用字体，字号30
# 画文字
draw.text(position, text4, fill=(0, 0, 0), font=font)  # fill参数为文字颜色

draw.line((12, 157, 91, 157), fill='black',width=3)
draw.line((12, 157, 12, 600), fill='black',width=3)
draw.line((12, 600, 285, 600), fill='black',width=3)
draw.line((285, 600, 285, 157), fill='black',width=3)
draw.line((285, 157, 192, 157), fill='black',width=3)
# 加载背景图像
background_image = image
background_image = background_image.resize((1400, 700), Image.Resampling.LANCZOS)  # 调整图像大小以适应窗口
background_photo = ImageTk.PhotoImage(background_image)

# 在背景画布上绘制背景图像
canvas_background.create_image(0, 0, anchor='nw', image=background_photo)
canvas_background.image = background_photo  # 保持对图像的引用


def upload_video(canvas):
    global cap, selected_video_path
    # 指定video1文件夹的路径
    folder_path = "video1"  # 请确保此路径正确指向您的video1文件夹
    # 使用filedialog.askopenfilename打开文件对话框，并限制路径为video1文件夹
    file_path = filedialog.askopenfilename(initialdir=folder_path, filetypes=[("Video files", "*.mp4 *.avi *.mkv")])

    # 检查文件路径是否包含指定的文件夹路径
    if file_path and folder_path in file_path:
        # 打开视频文件
        cap = cv2.VideoCapture(file_path)
        if not cap.isOpened():
            messagebox.showerror("Error", "无法打开视频文件")
            return

        # 读取视频的第一帧
        ret, frame = cap.read()
        if not ret:
            messagebox.showerror("Error", "无法读取视频帧")
            cap.release()
            return

        # 将OpenCV的BGR图像转换为RGB图像
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        # 将图像转换为PIL格式
        image = Image.fromarray(frame)
        # 将PIL图像转换为Tkinter兼容的图片
        image_tk = ImageTk.PhotoImage(image)

        # 在画布上显示图像
        canvas.create_image(0, 0, anchor='nw', image=image_tk)
        canvas.image = image_tk  # 保留对图像的引用

        # 设置selected_video_path
        selected_video_path = file_path

        # 使用after方法更新画布
        def update_canvas():
            if cap.isOpened():
                ret, frame = cap.read()
                if ret:
                    # 将OpenCV的BGR图像转换为RGB图像
                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                    # 将图像转换为PIL格式
                    image = Image.fromarray(frame)
                    # 将PIL图像转换为Tkinter兼容的图片
                    image_tk = ImageTk.PhotoImage(image)
                    # 在画布上显示图像
                    canvas.create_image(0, 0, anchor='nw', image=image_tk)
                    canvas.image = image_tk  # 保留对图像的引用
                    # 20毫秒后再次更新画布
                    window.after(20, update_canvas)
                else:
                    # 释放视频流
                    cap.release()

        # 开始更新画布
        update_canvas()
    else:
        # 如果用户选择的文件不在video1文件夹中，显示警告框
        tkMessageBox.showwarning("警告", "请选择video1文件夹中的视频文件。")




def return_main():
    # 在新线程中运行EfficientNet_uI_main.py脚本
    def run_script():
        subprocess.run(['python', 'EfficientNet_uI_main.py'])

    threading.Thread(target=run_script).start()

    # 等待子进程启动后立即销毁主窗口
    window.destroy()


def video_detection():
    global cap
    if cap:
        cap.release()  # 关闭上传视频正在播放的视频
    if not cap:
        messagebox.showerror("Error", "请先上传视频")
        return

    # 获取上传的视频文件名称
    video_name = os.path.basename(selected_video_path)

    # 获取E:\ch_PP-OCRv3\output文件夹中的所有视频文件
    output_folder_path = 'output\\'
    videos = [f for f in os.listdir(output_folder_path) if f.endswith(('.mp4', '.avi', '.mkv'))]

    # 检查是否有匹配的视频文件
    if video_name in videos:
        # 播放匹配的视频文件
        matching_video_path = os.path.join(output_folder_path, video_name)
        detection_video = cv2.VideoCapture(matching_video_path)
        if detection_video.isOpened():
            # 获取视频的原始分辨率
            width = int(detection_video.get(cv2.CAP_PROP_FRAME_WIDTH))
            height = int(detection_video.get(cv2.CAP_PROP_FRAME_HEIGHT))

            # 降低视频分辨率
            new_width = 1080
            new_height = int(height * (new_width / width))
            detection_video.set(cv2.CAP_PROP_FRAME_WIDTH, new_width)
            detection_video.set(cv2.CAP_PROP_FRAME_HEIGHT, new_height)

            # 创建一个新窗口
            new_window = tk.Toplevel(window)
            new_window.title("检测到的视频")
            new_window.geometry(f"{new_width}x{new_height}")

            # 创建一个画布用于在新窗口中显示视频
            canvas_video = tk.Canvas(new_window, width=new_width, height=new_height)
            canvas_video.pack()

            # 在新窗口的画布上播放检测完的视频
            def play_detected_video():
                global video_playing
                video_playing = True
                frame_count = 0
                while True:
                    ret, frame = detection_video.read()
                    if not ret:
                        break  # 视频播放完毕

                    # 使用opencv-python处理图像
                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                    image = Image.fromarray(frame)
                    image_tk = ImageTk.PhotoImage(image)

                    # 在画布上显示图像
                    def update_canvas_image():
                        if canvas_video and canvas_video.winfo_exists():
                            canvas_video.create_image(0, 0, anchor='nw', image=image_tk)
                            canvas_video.image = image_tk  # 保留对图像的引用
                        else:
                            video_playing = False

                    window.after(0, update_canvas_image)

                    frame_count += 1
                    time.sleep(1 / 30)  # Wait for about 30 frames per second

                # 释放视频流
                detection_video.release()
                video_playing = False

            # 在单独的线程中播放视频，以避免阻塞Tkinter的事件循环
            thread = threading.Thread(target=play_detected_video)
            thread.start()
        else:
            messagebox.showerror("Error", "无法打开视频文件")
    else:
        messagebox.showerror("Error", "output文件夹中没有匹配的视频文件")


# 创建一个大的画布区域
canvas_large = tk.Canvas(window, width=900, height=580, bg="#e6f2ff")
canvas_large.place(x=300, y=100)

# 创建按钮并放置在主窗口上
button_upload = tk.Button(window, width=13, text='上传视频', font=14, command=lambda: upload_video(canvas_large))
button_start_detection = tk.Button(window, width=13, text='视频检测', font=14, command=video_detection)
return_start_detection = tk.Button(window, width=13, text='返回系统', font=14, command=return_main)
# 将按钮放置在主窗口上
button_upload.place(x=35, y=170)
button_start_detection.place(x=35, y=230)
return_start_detection.place(x=35, y=290)
window.mainloop()

Python终端输入

#单张图片
python deploy/pipeline/pipeline.py --config deploy/pipeline/config/infer_cfg_pphuman.yml \
                                                   --image_file=test_image.jpg \
                                                   --device=gpu \

#图片文件夹
python deploy/pipeline/pipeline.py --config deploy/pipeline/config/infer_cfg_pphuman.yml \
                                                   --image_dir=images/ \
                                                   --device=gpu \

效果

在这里插入图片描述

perhaps°
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【目标检测-YOLO】PP-YOLO(v3版本)
博观约取，厚积薄发
03-31 711
本文下载的论文是 arXiv:2007.12099v3 [cs.CV] 3 Aug 2020 PP-YOLO: An Effective and Effificient Implementation of Object Detector 百度 摘要 Due to limitation of hardware, it is often necessary to sacrififice(牺牲)accuracy to ensure the infer speed of the detector in p.
【论文笔记】：PP-YOLO、PP-YOLOv2、PP-YOLO Tiny
Activewaste
05-03 6786
&Title PP-YOLO: An Effective and Efficient Implementation of Object Detector（2020） PP-YOLOv2: A Practical Object Detector（2021） &Summary 目标检测算法的准确性和推理速度不可兼得，本文的工作旨在通过tricks组合来平衡目标检测器的性能以及速度。 PP-YOLO： 45.2% mAP，速度高达72.9 FPS！FPS和mAP均超越YOLOv4，FPS也远
目标检测——PP-YOLO算法解读
lishanlu136的博客
03-19 2400
百度检测算法PP-YOLO算法解读
PP-YOLO
浅汐入梦的博客
04-24 7830
PP-YOLOv2的改进点 数据增强：+ MixUp Backbone：换R50 + Better Pre-Train + dcn Neck：+ SPP +CoordConv + DropBlock + PAN + MISH Loss：+ IoU Loss + IoU Aware Loss 其他：+ Large Batch Size + Grid Sensitive + EMA + Matrix NMS + Large Input Size （红色为 PP-YOLOv2 版本新添加的内容） .
opencv dnn模块 示例(18) 目标检测 object_detection 之 pp-yolo、pp-yolov2和pp-yolo tiny
热爱生活，忠于自己
10-13 887
PP-YOLO没有像yolo4那样死抠现有的SOTA网络结构，而是着眼于合理的tricks堆叠。通过有效的计算，很好的平衡了准确率以及推理时间，而其中的实验部分也非常适合学习炼丹的小伙伴。
PP-YOLO论文阅读笔记
weixin_45868623的博客
10-24 1531
PP-YOLO 的目标是实现一个有效性和效率相对平衡的对象检测器，可以直接应用于实际应用场景，而不是提出一种新的检测模型。PP-YOLO主要尝试将现有的各种技巧结合起来，在保证速度几乎不变的情况下，尽量不增加模型参数和触发器的数量，以达到尽可能提高检测器精度的目的。通过结合多种技巧，PP-YOLO可以在有效性(45.2%mAP)和效率(72.9FPS)之间实现更好的平衡，超过现有的最先进探测器，如EfficientDet和 YOLOv4。对于数据扩充，直接使用了最基本的MixUp。
论文阅读笔记 | 目标检测算法——PP-YOLO
Clichong
09-29 1416
如有错误，恳请指出。 文章目录1. Introduction2. Related Work3. PP-YOLO3.1 Architecture3.1.1 Backbone3.1.2 Detection Neck3.1.3 Detection Head3.2 Selection of Tricks3.2.1 Larger Batch Size3.2.2 EMA3.2.3 DropBlock3.2.4 IoU Loss3.2.5 IoU Aware3.2.6 Grid Sensitive3.2.7 Matr.
YOLO系列目标检测算法——PP-YOLO
AI-Mei的博客
12-06 2698
由于硬件的限制，往往需要舍弃准确率来确保算法的推理速度。本文的目的是实现一种具有相对平衡的既有效又高效的目标检测器，可以直接应用于实际的应用场景，而不是提出一种新的检测模型。以YOLOv3为基础进行开发，主要尝试结合现有的各种几乎不增加模型参数和FLOPs的多个的tricks，以尽可能提高检测器的精度，同时确保速度几乎不变。由于本文的所有实验都是基于PaddlePaddle进行的，所以称之为PP-YOLO。
【PP-YOLO】
m0_62571112的博客
06-22 1138
PPYOLO：不容错过的目标检测调参Tricks1. 摘要目标检测是计算机视觉一个重要的领域。
PP-YOLO模型.zip
03-04
PP-YOLO模型
PaddleX22、PP-Yolo：手把手教你训练、加密、部署目标检测模型
11-21
PaddleX22、PP-Yolo：手把手教你训练、加密、部署目标检测模型
中软杯baseline基于百度飞桨的单/多镜头行人追踪，使用百度飞桨PaddleDetection套件的PP-YOLO+Sort
06-04
PP-YOLO是PaddlePaddle团队优化的YOLOv3模型，具有较高的检测速度和精度，非常适合实时行人检测。PP-YOLO通过以下技术提升了性能： 1. **Path Aggregation Network (PAN)**：增强特征提取能力，提高小目标的检测效果...
yolodet-pytorch:在pytorch中复制YOLO系列论文，包括YOLOv4，PP-YOLO，YOLOv5，YOLOv3等
05-02
YOLODet提供了丰富的模型，涵盖最新YOLO检测算法的复现，包含YOLOv5、YOLOv4、PP-YOLO、YOLOv3等YOLO系列目标检测算法。 高灵活度： YOLODet通过模块化设计来解耦各个组件，基于配置文件可以轻松地搭建各种检测模型...
baseline-基于百度飞桨的单多镜头行人追踪，使用百度飞桨PaddleDetection套件的PP-YOLO+Sort算法
06-19
YOLO 有多个版本，比如 YOLOv1、YOLOv2、YOLOv3、YOLOv4 和 YOLOv5，随着版本的迭代，模型的精度和速度都有所提升。YOLOv5 版本尤其受到了开发者社区的广泛关注，因为它在保持高效的同时，也提供了较高的检测性能。
yolov5驾驶员不规范行为检测
最新发布
java一只鱼的博客
06-27 272
随着汽车工业的迅速发展和交通拥堵的加剧，驾驶员在行车过程中的不规范行为成为了导致交通事故频发的重要因素之一。为了减少交通事故的发生，保障道路安全，提高驾驶员的行车安全意识，本研究致力于实现驾驶员不规范行为的自动检测[1]。通过利用先进的人工智能和计算机视觉技术，可以实时监控驾驶员的行为，及时发现并纠正不规范行为，从而降低事故风险。本课题的主要目标是开发一个基于YOLOV5、Dlib、OpenCV及PySide技术的驾驶员不规范行为自动检测系统。
目标检测算法之YOLO（YOLOv8）
weixin_52862386的博客
06-25 749
其中卷积模块是使用了类似于ELAN的CSPlayer_2conv，分类头采用了解耦结构并使用了anchor-free的方法，损失函数中引入了VFL损失，标签分配采取了类似于yolov6的TAL方法，训练策略是采用最后10个epoch关闭Mosaic数据增强的方式。DFL的思想是基于回归任务预测的唯一性导致模型难以精确的回归到目标值上，转而通过求概率分布的方式，使预测值在目标出取得较大的概率，从而实现一种通过类似于“模糊”定位的方式提高模型收敛的速度，同时提高检测模型的准确率。这里只分析VFL的损失值。
目标检测算法之YOLO（YOLOv7）
weixin_52862386的博客
06-25 917
从现在的角度去看yolov7，可以发现其ELAN的方法是有效的，在后续的版本中也多次被用到或者改进。而如今标签分配更多的是使用TAL策略。yolov7的热度明显不如yolov8，很多人在v7上fine-tune自己的数据集的效果甚至不如v5。不过这也是现如今新算法的一个普遍问题，许多算法过度追求SOTA从而导致模型的标签只能在某些数据集上取得较好的效果，所以对于新的算法更多的是去了解新的思想。然后在此基础上去创新或者调参，从而获得更好地模型效果。
【课程总结】Day12：YOLO的深入了解
Deadwalk的专栏
06-27 691
在【课程总结】Day11（下）：YOLO的入门使用一节中，我们已经了解YOLO的使用方法，使用过程非常简单，训练时只需要三行代码：引入YOLO，构建模型，训练模型；预测时也同样简单，只需要两行代码：引入YOLO，预测图像即可。以上过程简单主要是ultralytics的代码库已经做了封装，使得使用者集中精力在模型训练和预测上。为了更加深入了解YOLO的实现原理，本章内容将对YOLO的工程结构、模型构建过程、模型训练过程尝试深入探究。
YOLO系列的综述文章分享
10-23
官方经典的YOLOv1-v8 YOLO的改进：PP-YOLO，YOLOX，YOLOR，DAMO-YOLO，YOLO with Transformers

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值