devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于YOLOv5、YOLOv8的烟雾报警检测（超实用项目）_python烟雾报警系统

作者：2023面试高手 | 2024-02-27 07:04:15

赞

踩

python烟雾报警系统

目录

1.简介

2.YOLO算法

3.基于YOLOv5、YOLOv8的烟雾检测报警系统

3.1gui界面主代码 

3.2YOLOv5主代码

视频已上传b站 

YOLOv5、YOLOv8检测-烟雾检测报警系统_哔哩哔哩_bilibili

本文为系列专栏，包括各种YOLO检测算法项目、追踪算法项目、双目视觉、深度结构光相机测距测速三维测量项目等

专栏持续更新中，有需要的小伙伴可私聊，接项目定制。

1.简介

随着科技的不断发展，人工智能技术在各个领域得到广泛应用。其中，计算机视觉是人工智能领域中的一个重要分支，它主要研究如何使机器“看”和“理解”图像或视频。在计算机视觉领域，目标检测是一个关键问题，它涉及识别图像或视频中的特定对象，并确定它们的位置。烟雾检测作为目标检测的一个重要应用领域，对于及时发现火灾、减少人员伤亡和财产损失具有重要意义。

  1. 火灾安全：烟雾是火灾初期最常见且最早的指示物之一。快速准确地检测和报警可以帮助尽早采取适当的措施，以防止火灾蔓延和减少损失。通过基于YOLOv5的烟雾报警系统，可以实现实时、高效的烟雾检测，提供及时的火灾预警。

  2. 人员安全：烟雾中的有害气体和毒素可能对人体健康产生严重威胁。火灾发生时，人们通常可能会处于迷惘或恐慌状态，很难准确判断烟雾的存在和危害程度。一个可靠的烟雾报警系统可以提供及早的警示，帮助人们采取必要的行动，增加人员的逃生机会。

  3. 资产保护：火灾造成的财产损失往往巨大。通过及时发现和报警，可以提高火灾发生时应对的效率，减少财产损失。基于YOLOv5的烟雾报警系统可以实现对大范围区域进行监控和烟雾检测，可以在火灾发生前尽早发出警报，有助于及时采取措施保护财产。

  4. 自动化和智能化：基于YOLOv5的烟雾报警系统能够利用计算机视觉技术自动实现烟雾检测，无需人工干预，并能够实现高精度的目标检测。这种系统的自动化和智能化特性可以降低人力成本，提高检测效率和准确性。

总之，基于YOLOv5的烟雾报警系统对于火灾安全、人员安全、资产保护以及自动化智能化等方面都具有重要的背景意义，可以提高火灾预警和处理的效率，减少火灾带来的损失。

本项目旨在基于YOLOv5和YOLOv8这两个先进的目标检测模型，开展火灾检测的研究和应用。YOLO（You Only Look Once）是一种实时目标检测算法，它将目标检测任务转化为一个回归问题，通过单次前向传递神经网络即可得到图像中所有目标的类别和位置。YOLOv5是YOLO系列中的最新版本，它在精度和速度之间取得了很好的平衡，被广泛应用于各种实时目标检测任务。

在本项目中，我们将探讨火灾检测领域的挑战和需求，介绍YOLOv5和YOLOv8的基本原理和算法结构，以及在实际火灾检测场景中的应用。通过本项目的研究，我们希望能够为提高火灾检测的准确性和效率，保障人们的生命财产安全，做出积极贡献。

希望本项目能够为火灾检测领域的研究和实际应用提供有益的参考和启示，推动人工智能技术在火灾安全领域的进一步发展和应用。

2.YOLO算法

YOLO（You Only Look Once）是一种高效的实时目标检测算法，它将目标检测任务转化为一个回归问题，通过单次前向传递神经网络即可得到图像中所有目标的类别和位置。相较于传统的目标检测方法，YOLO具有更快的速度和较高的准确性，使其成为计算机视觉领域中的重要算法之一。

YOLO算法的基本思想是将输入图像划分为一个固定大小的网格（grid），每个网格负责预测图像中是否包含目标以及目标的位置和类别。与传统的滑动窗口方法不同，YOLO将目标检测任务转化为一个回归问题，同时预测所有目标的位置和类别，避免了重复计算，因此速度更快。

以下是YOLO算法的主要特点和步骤：

划分网格： 将输入图像划分为SxS个网格，每个网格负责预测该网格内是否包含目标。

预测框和类别： 每个网格预测B个边界框（bounding boxes）以及每个边界框的置信度（confidence）和类别概率。置信度表示边界框的准确性，类别概率表示目标属于不同类别的概率。

计算损失函数： YOLO使用多任务损失函数，包括边界框坐标的回归损失、置信度的损失（包括目标是否存在的损失和目标位置的精度损失）、类别概率的损失。通过最小化这些损失，网络可以学习到准确的目标位置和类别信息。

非极大值抑制（NMS）： 在预测结果中，可能存在多个边界框对同一个目标的重复检测。为了去除这些重叠的边界框，使用NMS算法来选择具有最高置信度的边界框，并消除与其IoU（交并比）高于阈值的其他边界框。

输出结果： 最终，YOLO输出图像中所有目标的位置和类别信息，以及它们的置信度分数。

YOLO的优势在于它的速度和准确性，它能够实时处理高分辨率的图像，并且在不同尺度和大小的目标上具有很好的泛化能力。这使得YOLO广泛应用于实时目标检测、视频分析、自动驾驶等领域。

3.基于YOLOv5、YOLOv8的烟雾检测报警系统

部分代码展示

3.1gui界面主代码 

  1. from PyQt5.QtWidgets import QApplication, QMainWindow, QFileDialog, QMenu, QAction
  2. from main_win.win import Ui_mainWindow
  3. from PyQt5.QtCore import Qt, QPoint, QTimer, QThread, pyqtSignal
  4. from PyQt5.QtGui import QImage, QPixmap, QPainter, QIcon
  5.  
  6. import sys
  7. import os
  8. import json
  9. import numpy as np
  10. import torch
  11. import torch.backends.cudnn as cudnn
  12. import os
  13. import time
  14. import cv2
  15.  
  16. from models.experimental import attempt_load
  17. from utils.datasets import LoadImages, LoadWebcam
  18. from utils.CustomMessageBox import MessageBox
  19. # LoadWebcam 的最后一个返回值改为 self.cap
  20. from utils.general import check_img_size, check_requirements, check_imshow, colorstr, non_max_suppression, \
  21.     apply_classifier, scale_coords, xyxy2xywh, strip_optimizer, set_logging, increment_path, save_one_box
  22. from utils.plots import colors, plot_one_box, plot_one_box_PIL
  23. from utils.torch_utils import select_device, load_classifier, time_sync
  24. from utils.capnums import Camera
  25. from dialog.rtsp_win import Window
  26.  
  27.  
  28. class DetThread(QThread):
  29.     send_img = pyqtSignal(np.ndarray)
  30.     send_raw = pyqtSignal(np.ndarray)
  31.     send_statistic = pyqtSignal(dict)
  32.     # 发送信号：正在检测/暂停/停止/检测结束/错误报告
  33.     send_msg = pyqtSignal(str)
  34.     send_percent = pyqtSignal(int)
  35.     send_fps = pyqtSignal(str)
  36.  
  37.     def __init__(self):
  38.         super(DetThread, self).__init__()
  39.         self.weights = './yolov5s.pt'           # 设置权重
  40.         self.current_weight = './yolov5s.pt'    # 当前权重
  41.         self.source = '0'                       # 视频源
  42.         self.conf_thres = 0.25                  # 置信度
  43.         self.iou_thres = 0.45                   # iou
  44.         self.jump_out = False                   # 跳出循环
  45.         self.is_continue = True                 # 继续/暂停
  46.         self.percent_length = 1000              # 进度条
  47.         self.rate_check = True                  # 是否启用延时
  48.         self.rate = 100                         # 延时HZ
  49.         self.save_fold = './result'             # 保存文件夹
  50.  
  51.     @torch.no_grad()
  52.     def run(self,
  53.             imgsz=640,  # inference size (pixels)
  54.             max_det=1000,  # maximum detections per image
  55.             device='',  # cuda device, i.e. 0 or 0,1,2,3 or cpu
  56.             view_img=True,  # show results
  57.             save_txt=False,  # save results to *.txt
  58.             save_conf=False,  # save confidences in --save-txt labels
  59.             save_crop=False,  # save cropped prediction boxes
  60.             nosave=False,  # do not save images/videos
  61.             classes=None,  # filter by class: --class 0, or --class 0 2 3
  62.             agnostic_nms=False,  # class-agnostic NMS
  63.             augment=False,  # augmented inference
  64.             visualize=False,  # visualize features
  65.             update=False,  # update all models
  66.             project='runs/detect',  # save results to project/name
  67.             name='exp',  # save results to project/name
  68.             exist_ok=False,  # existing project/name ok, do not increment
  69.             line_thickness=3,  # bounding box thickness (pixels)
  70.             hide_labels=False,  # hide labels
  71.             hide_conf=False,  # hide confidences
  72.             half=False,  # use FP16 half-precision inference
  73.             ):
  74.  
  75.         # Initialize
  76.         try:
  77.             device = select_device(device)
  78.             half &= device.type != 'cpu'  # half precision only supported on CUDA
  79.  
  80.             # Load model
  81.             model = attempt_load(self.weights, map_location=device)  # load FP32 model
  82.             num_params = 0
  83.             for param in model.parameters():
  84.                 num_params += param.numel()
  85.             stride = int(model.stride.max())  # model stride
  86.             imgsz = check_img_size(imgsz, s=stride)  # check image size
  87.             names = model.module.names if hasattr(model, 'module') else model.names  # get class names
  88.             if half:
  89.                 model.half()  # to FP16
  90.  
  91.             # Dataloader
  92.             if self.source.isnumeric() or self.source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://')):
  93.                 view_img = check_imshow()
  94.                 cudnn.benchmark = True  # set True to speed up constant image size inference
  95.                 dataset = LoadWebcam(self.source, img_size=imgsz, stride=stride)
  96.                 # bs = len(dataset)  # batch_size
  97.             else:
  98.                 dataset = LoadImages(self.source, img_size=imgsz, stride=stride)
  99.  
  100.             # Run inference
  101.             if device.type != 'cpu':
  102.                 model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))  # run once
  103.             count = 0
  104.             # 跳帧检测
  105.             jump_count = 0
  106.             start_time = time.time()
  107.             dataset = iter(dataset)
  108.  
  109.             while True:
  110.                 # 手动停止
  111.                 if self.jump_out:
  112.                     self.vid_cap.release()
  113.                     self.send_percent.emit(0)
  114.                     self.send_msg.emit('停止')
  115.                     if hasattr(self, 'out'):
  116.                         self.out.release()
  117.                     break
  118.                 # 临时更换模型
  119.                 if self.current_weight != self.weights:
  120.                     # Load model
  121.                     model = attempt_load(self.weights, map_location=device)  # load FP32 model
  122.                     num_params = 0
  123.                     for param in model.parameters():
  124.                         num_params += param.numel()
  125.                     stride = int(model.stride.max())  # model stride
  126.                     imgsz = check_img_size(imgsz, s=stride)  # check image size
  127.                     names = model.module.names if hasattr(model, 'module') else model.names  # get class names
  128.                     if half:
  129.                         model.half()  # to FP16
  130.                     # Run inference
  131.                     if device.type != 'cpu':
  132.                         model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))  # run once
  133.                     self.current_weight = self.weights
  134.                 # 暂停开关
  135.                 if self.is_continue:
  136.                     path, img, im0s, self.vid_cap = next(dataset)
  137.                     # jump_count += 1
  138.                     # if jump_count % 5 != 0:
  139.                     #     continue
  140.                     count += 1
  141.                     # 每三十帧刷新一次输出帧率
  142.                     if count % 30 == 0 and count >= 30:
  143.                         fps = int(30/(time.time()-start_time))
  144.                         self.send_fps.emit('fps：'+str(fps))
  145.                         start_time = time.time()
  146.                     if self.vid_cap:
  147.                         percent = int(count/self.vid_cap.get(cv2.CAP_PROP_FRAME_COUNT)*self.percent_length)
  148.                         self.send_percent.emit(percent)
  149.                     else:
  150.                         percent = self.percent_length
  151.  
  152.                     statistic_dic = {name: 0 for name in names}
  153.                     img = torch.from_numpy(img).to(device)
  154.                     img = img.half() if half else img.float()  # uint8 to fp16/32
  155.                     img /= 255.0  # 0 - 255 to 0.0 - 1.0
  156.                     if img.ndimension() == 3:
  157.                         img = img.unsqueeze(0)
  158.  
  159.                     pred = model(img, augment=augment)[0]
  160.  
  161.                     # Apply NMS
  162.                     pred = non_max_suppression(pred, self.conf_thres, self.iou_thres, classes, agnostic_nms, max_det=max_det)
  163.                     # Process detections
  164.                     for i, det in enumerate(pred):  # detections per image
  165.                         im0 = im0s.copy()
  166.  
  167.                         if len(det):
  168.                             # Rescale boxes from img_size to im0 size
  169.                             det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
  170.  
  171.                             # Write results
  172.                             for *xyxy, conf, cls in reversed(det):
  173.                                 c = int(cls)  # integer class
  174.                                 statistic_dic[names[c]] += 1
  175.                                 label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')
  176.                                 # im0 = plot_one_box_PIL(xyxy, im0, label=label, color=colors(c, True), line_thickness=line_thickness)  # 中文标签画框，但是耗时会增加
  177.                                 plot_one_box(xyxy, im0, label=label, color=colors(c, True),
  178.                                              line_thickness=line_thickness)
  179.  
  180.                     # 控制视频发送频率
  181.                     if self.rate_check:
  182.                         time.sleep(1/self.rate)
  183.                     self.send_img.emit(im0)
  184.                     self.send_raw.emit(im0s if isinstance(im0s, np.ndarray) else im0s[0])
  185.                     self.send_statistic.emit(statistic_dic)
  186.                     # 如果自动录制
  187.                     if self.save_fold:
  188.                         os.makedirs(self.save_fold, exist_ok=True)  # 路径不存在，自动保存
  189.                         # 如果输入是图片
  190.                         if self.vid_cap is None:
  191.                             save_path = os.path.join(self.save_fold,
  192.                                                      time.strftime('%Y_%m_%d_%H_%M_%S',
  193.                                                                    time.localtime()) + '.jpg')
  194.                             cv2.imwrite(save_path, im0)
  195.                         else:
  196.                             if count == 1:  # 第一帧时初始化录制
  197.                                 # 以视频原始帧率进行录制
  198.                                 ori_fps = int(self.vid_cap.get(cv2.CAP_PROP_FPS))
  199.                                 if ori_fps == 0:
  200.                                     ori_fps = 25
  201.                                 # width = int(self.vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
  202.                                 # height = int(self.vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
  203.                                 width, height = im0.shape[1], im0.shape[0]
  204.                                 save_path = os.path.join(self.save_fold, time.strftime('%Y_%m_%d_%H_%M_%S', time.localtime()) + '.mp4')
  205.                                 self.out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*"mp4v"), ori_fps,
  206.                                                            (width, height))
  207.                             self.out.write(im0)
  208.                     if percent == self.percent_length:
  209.                         print(count)
  210.                         self.send_percent.emit(0)
  211.                         self.send_msg.emit('检测结束')
  212.                         if hasattr(self, 'out'):
  213.                             self.out.release()
  214.                         # 正常跳出循环
  215.                         break
  216.  
  217.         except Exception as e:
  218.             self.send_msg.emit('%s' % e)

3.2YOLOv5主代码

  1. """Train a YOLOv5 model on a custom dataset
  2. Usage:
  3.     $ python path/to/train.py --data coco128.yaml --weights yolov5s.pt --img 640
  4. """
  5.  
  6. import argparse
  7. import logging
  8. import os
  9. import random
  10. import sys
  11. import time
  12. import warnings
  13. from copy import deepcopy
  14. from pathlib import Path
  15. from threading import Thread
  16.  
  17. import math
  18. import numpy as np
  19. import torch.distributed as dist
  20. import torch.nn as nn
  21. import torch.nn.functional as F
  22. import torch.optim as optim
  23. import torch.optim.lr_scheduler as lr_scheduler
  24. import torch.utils.data
  25. import yaml
  26. from torch.cuda import amp
  27. from torch.nn.parallel import DistributedDataParallel as DDP
  28. from torch.utils.tensorboard import SummaryWriter
  29. from tqdm import tqdm
  30.  
  31. FILE = Path(__file__).absolute()
  32. sys.path.append(FILE.parents[0].as_posix())  # add yolov5/ to path
  33.  
  34. import val  # for end-of-epoch mAP
  35. from models.experimental import attempt_load
  36. from models.yolo import Model
  37. from utils.autoanchor import check_anchors
  38. from utils.datasets import create_dataloader
  39. from utils.general import labels_to_class_weights, increment_path, labels_to_image_weights, init_seeds, \
  40.     strip_optimizer, get_latest_run, check_dataset, check_file, check_git_status, check_img_size, \
  41.     check_requirements, print_mutation, set_logging, one_cycle, colorstr
  42. from utils.google_utils import attempt_download
  43. from utils.loss import ComputeLoss
  44. from utils.plots import plot_images, plot_labels, plot_results, plot_evolution
  45. from utils.torch_utils import ModelEMA, select_device, intersect_dicts, torch_distributed_zero_first, de_parallel
  46. from utils.wandb_logging.wandb_utils import WandbLogger, check_wandb_resume
  47. from utils.metrics import fitness
  48.  
  49. LOGGER = logging.getLogger(__name__)
  50. LOCAL_RANK = int(os.getenv('LOCAL_RANK', -1))  # https://pytorch.org/docs/stable/elastic/run.html
  51. RANK = int(os.getenv('RANK', -1))
  52. WORLD_SIZE = int(os.getenv('WORLD_SIZE', 1))
  53.  
  54.  
  55. def train(hyp,  # path/to/hyp.yaml or hyp dictionary
  56.           opt,
  57.           device,
  58.           ):
  59.     save_dir, epochs, batch_size, weights, single_cls, evolve, data, cfg, resume, noval, nosave, workers, = \
  60.         opt.save_dir, opt.epochs, opt.batch_size, opt.weights, opt.single_cls, opt.evolve, opt.data, opt.cfg, \
  61.         opt.resume, opt.noval, opt.nosave, opt.workers
  62.  
  63.     # Directories
  64.     save_dir = Path(save_dir)
  65.     wdir = save_dir / 'weights'
  66.     wdir.mkdir(parents=True, exist_ok=True)  # make dir
  67.     last = wdir / 'last.pt'
  68.     best = wdir / 'best.pt'
  69.     results_file = save_dir / 'results.txt'
  70.  
  71.     # Hyperparameters
  72.     if isinstance(hyp, str):
  73.         with open(hyp) as f:
  74.             hyp = yaml.safe_load(f)  # load hyps dict
  75.     LOGGER.info(colorstr('hyperparameters: ') + ', '.join(f'{k}={v}' for k, v in hyp.items()))
  76.  
  77.     # Save run settings
  78.     with open(save_dir / 'hyp.yaml', 'w') as f:
  79.         yaml.safe_dump(hyp, f, sort_keys=False)
  80.     with open(save_dir / 'opt.yaml', 'w') as f:
  81.         yaml.safe_dump(vars(opt), f, sort_keys=False)
  82.  
  83.     # Configure
  84.     plots = not evolve  # create plots
  85.     cuda = device.type != 'cpu'
  86.     init_seeds(1 + RANK)
  87.     with open(data) as f:
  88.         data_dict = yaml.safe_load(f)  # data dict
  89.  
  90.     # Loggers
  91.     loggers = {'wandb': None, 'tb': None}  # loggers dict
  92.     if RANK in [-1, 0]:
  93.         # TensorBoard
  94.         if not evolve:
  95.             prefix = colorstr('tensorboard: ')
  96.             LOGGER.info(f"{prefix}Start with 'tensorboard --logdir {opt.project}', view at http://localhost:6006/")
  97.             loggers['tb'] = SummaryWriter(str(save_dir))
  98.  
  99.         # W&B
  100.         opt.hyp = hyp  # add hyperparameters
  101.         run_id = torch.load(weights).get('wandb_id') if weights.endswith('.pt') and os.path.isfile(weights) else None
  102.         run_id = run_id if opt.resume else None  # start fresh run if transfer learning
  103.         wandb_logger = WandbLogger(opt, save_dir.stem, run_id, data_dict)
  104.         loggers['wandb'] = wandb_logger.wandb
  105.         if loggers['wandb']:
  106.             data_dict = wandb_logger.data_dict
  107.             weights, epochs, hyp = opt.weights, opt.epochs, opt.hyp  # may update weights, epochs if resuming
  108.  
  109.     nc = 1 if single_cls else int(data_dict['nc'])  # number of classes
  110.     names = ['item'] if single_cls and len(data_dict['names']) != 1 else data_dict['names']  # class names
  111.     assert len(names) == nc, '%g names found for nc=%g dataset in %s' % (len(names), nc, data)  # check
  112.     is_coco = data.endswith('coco.yaml') and nc == 80  # COCO dataset
  113.  
  114.     # Model
  115.     pretrained = weights.endswith('.pt')
  116.     if pretrained:
  117.         with torch_distributed_zero_first(RANK):
  118.             weights = attempt_download(weights)  # download if not found locally
  119.         ckpt = torch.load(weights, map_location=device)  # load checkpoint
  120.         model = Model(cfg or ckpt['model'].yaml, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
  121.         exclude = ['anchor'] if (cfg or hyp.get('anchors')) and not resume else []  # exclude keys
  122.         state_dict = ckpt['model'].float().state_dict()  # to FP32
  123.         state_dict = intersect_dicts(state_dict, model.state_dict(), exclude=exclude)  # intersect
  124.         model.load_state_dict(state_dict, strict=False)  # load
  125.         LOGGER.info('Transferred %g/%g items from %s' % (len(state_dict), len(model.state_dict()), weights))  # report
  126.     else:
  127.         model = Model(cfg, ch=3, nc=nc, anchors=hyp.get('anchors')).to(device)  # create
  128.     with torch_distributed_zero_first(RANK):
  129.         check_dataset(data_dict)  # check
  130.     train_path = data_dict['train']
  131.     val_path = data_dict['val']
  132.  
  133.     # Freeze
  134.     freeze = []  # parameter names to freeze (full or partial)
  135.     for k, v in model.named_parameters():
  136.         v.requires_grad = True  # train all layers
  137.         if any(x in k for x in freeze):
  138.             print('freezing %s' % k)
  139.             v.requires_grad = False
  140.  
  141.     # Optimizer
  142.     nbs = 64  # nominal batch size
  143.     accumulate = max(round(nbs / batch_size), 1)  # accumulate loss before optimizing
  144.     hyp['weight_decay'] *= batch_size * accumulate / nbs  # scale weight_decay
  145.     LOGGER.info(f"Scaled weight_decay = {hyp['weight_decay']}")
  146.  
  147.     pg0, pg1, pg2 = [], [], []  # optimizer parameter groups
  148.     for k, v in model.named_modules():
  149.         if hasattr(v, 'bias') and isinstance(v.bias, nn.Parameter):
  150.             pg2.append(v.bias)  # biases
  151.         if isinstance(v, nn.BatchNorm2d):
  152.             pg0.append(v.weight)  # no decay
  153.         elif hasattr(v, 'weight') and isinstance(v.weight, nn.Parameter):
  154.             pg1.append(v.weight)  # apply decay
  155.  
  156.     if opt.adam:
  157.         optimizer = optim.Adam(pg0, lr=hyp['lr0'], betas=(hyp['momentum'], 0.999))  # adjust beta1 to momentum
  158.     else:
  159.         optimizer = optim.SGD(pg0, lr=hyp['lr0'], momentum=hyp['momentum'], nesterov=True)
  160.  
  161.     optimizer.add_param_group({'params': pg1, 'weight_decay': hyp['weight_decay']})  # add pg1 with weight_decay
  162.     optimizer.add_param_group({'params': pg2})  # add pg2 (biases)
  163.     LOGGER.info('Optimizer groups: %g .bias, %g conv.weight, %g other' % (len(pg2), len(pg1), len(pg0)))
  164.     del pg0, pg1, pg2
  165.  
  166.     # Scheduler https://arxiv.org/pdf/1812.01187.pdf
  167.     # https://pytorch.org/docs/stable/_modules/torch/optim/lr_scheduler.html#OneCycleLR
  168.     if opt.linear_lr:
  169.         lf = lambda x: (1 - x / (epochs - 1)) * (1.0 - hyp['lrf']) + hyp['lrf']  # linear
  170.     else:
  171.         lf = one_cycle(1, hyp['lrf'], epochs)  # cosine 1->hyp['lrf']
  172.     scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lf)
  173.     # plot_lr_scheduler(optimizer, scheduler, epochs)
  174.  
  175.     # EMA
  176.     ema = ModelEMA(model) if RANK in [-1, 0] else None
  177.  
  178.     # Resume
  179.     start_epoch, best_fitness = 0, 0.0
  180.     if pretrained:
  181.         # Optimizer
  182.         if ckpt['optimizer'] is not None:
  183.             optimizer.load_state_dict(ckpt['optimizer'])
  184.             best_fitness = ckpt['best_fitness']
  185.  
  186.         # EMA
  187.         if ema and ckpt.get('ema'):
  188.             ema.ema.load_state_dict(ckpt['ema'].float().state_dict())
  189.             ema.updates = ckpt['updates']
  190.  
  191.         # Results
  192.         if ckpt.get('training_results') is not None:
  193.             results_file.write_text(ckpt['training_results'])  # write results.txt
  194.  
  195.         # Epochs
  196.         start_epoch = ckpt['epoch'] + 1
  197.         if resume:
  198.             assert start_epoch > 0, '%s training to %g epochs is finished, nothing to resume.' % (weights, epochs)
  199.         if epochs < start_epoch:
  200.             LOGGER.info('%s has been trained for %g epochs. Fine-tuning for %g additional epochs.' %
  201.                         (weights, ckpt['epoch'], epochs))
  202.             epochs += ckpt['epoch']  # finetune additional epochs
  203.  
  204.         del ckpt, state_dict
  205.  
  206.     # Image sizes
  207.     gs = max(int(model.stride.max()), 32)  # grid size (max stride)
  208.     nl = model.model[-1].nl  # number of detection layers (used for scaling hyp['obj'])
  209.     imgsz = check_img_size(opt.imgsz, gs)  # verify imgsz is gs-multiple
  210.  
  211.     # DP mode
  212.     if cuda and RANK == -1 and torch.cuda.device_count() > 1:
  213.         logging.warning('DP not recommended, instead use torch.distributed.run for best DDP Multi-GPU results.\n'
  214.                         'See Multi-GPU Tutorial at https://github.com/ultralytics/yolov5/issues/475 to get started.')
  215.         model = torch.nn.DataParallel(model)
  216.  
  217.     # SyncBatchNorm
  218.     if opt.sync_bn and cuda and RANK != -1:
  219.         raise Exception('can not train with --sync-bn, known issue https://github.com/ultralytics/yolov5/issues/3998')
  220.         model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model).to(device)
  221.         LOGGER.info('Using SyncBatchNorm()')
  222.  
  223.     # Trainloader
  224.     train_loader, dataset = create_dataloader(train_path, imgsz, batch_size // WORLD_SIZE, gs, single_cls,
  225.                                               hyp=hyp, augment=True, cache=opt.cache_images, rect=opt.rect, rank=RANK,
  226.                                               workers=workers, image_weights=opt.image_weights, quad=opt.quad,
  227.                                               prefix=colorstr('train: '))
  228.     mlc = np.concatenate(dataset.labels, 0)[:, 0].max()  # max label class
  229.     nb = len(train_loader)  # number of batches
  230.     assert mlc < nc, 'Label class %g exceeds nc=%g in %s. Possible class labels are 0-%g' % (mlc, nc, data, nc - 1)
  231.  
  232.     # Process 0
  233.     if RANK in [-1, 0]:
  234.         val_loader = create_dataloader(val_path, imgsz, batch_size // WORLD_SIZE * 2, gs, single_cls,
  235.                                        hyp=hyp, cache=opt.cache_images and not noval, rect=True, rank=-1,
  236.                                        workers=workers, pad=0.5,
  237.                                        prefix=colorstr('val: '))[0]
  238.  
  239.         if not resume:
  240.             labels = np.concatenate(dataset.labels, 0)
  241.             # c = torch.tensor(labels[:, 0])  # classes
  242.             # cf = torch.bincount(c.long(), minlength=nc) + 1.  # frequency
  243.             # model._initialize_biases(cf.to(device))
  244.             if plots:
  245.                 plot_labels(labels, names, save_dir, loggers)
  246.  
  247.             # Anchors
  248.             if not opt.noautoanchor:
  249.                 check_anchors(dataset, model=model, thr=hyp['anchor_t'], imgsz=imgsz)
  250.             model.half().float()  # pre-reduce anchor precision
  251.  
  252.     # DDP mode
  253.     if cuda and RANK != -1:
  254.         model = DDP(model, device_ids=[LOCAL_RANK], output_device=LOCAL_RANK)
  255.  
  256.     # Model parameters
  257.     hyp['box'] *= 3. / nl  # scale to layers
  258.     hyp['cls'] *= nc / 80. * 3. / nl  # scale to classes and layers
  259.     hyp['obj'] *= (imgsz / 640) ** 2 * 3. / nl  # scale to image size and layers
  260.     hyp['label_smoothing'] = opt.label_smoothing
  261.     model.nc = nc  # attach number of classes to model
  262.     model.hyp = hyp  # attach hyperparameters to model
  263.     model.gr = 1.0  # iou loss ratio (obj_loss = 1.0 or iou)
  264.     model.class_weights = labels_to_class_weights(dataset.labels, nc).to(device) * nc  # attach class weights
  265.     model.names = names
  266.  
  267.     # Start training
  268.     t0 = time.time()
  269.     nw = max(round(hyp['warmup_epochs'] * nb), 1000)  # number of warmup iterations, max(3 epochs, 1k iterations)
  270.     # nw = min(nw, (epochs - start_epoch) / 2 * nb)  # limit warmup to < 1/2 of training
  271.     last_opt_step = -1
  272.     maps = np.zeros(nc)  # mAP per class
  273.     results = (0, 0, 0, 0, 0, 0, 0)  # P, R, mAP@.5, mAP@.5-.95, val_loss(box, obj, cls)
  274.     scheduler.last_epoch = start_epoch - 1  # do not move
  275.     scaler = amp.GradScaler(enabled=cuda)
  276.     compute_loss = ComputeLoss(model)  # init loss class
  277.     LOGGER.info(f'Image sizes {imgsz} train, {imgsz} val\n'
  278.                 f'Using {train_loader.num_workers} dataloader workers\n'
  279.                 f'Logging results to {save_dir}\n'
  280.                 f'Starting training for {epochs} epochs...')
  281.     for epoch in range(start_epoch, epochs):  # epoch ------------------------------------------------------------------
  282.         model.train()
  283.  
  284.         # Update image weights (optional)
  285.         if opt.image_weights:
  286.             # Generate indices
  287.             if RANK in [-1, 0]:
  288.                 cw = model.class_weights.cpu().numpy() * (1 - maps) ** 2 / nc  # class weights
  289.                 iw = labels_to_image_weights(dataset.labels, nc=nc, class_weights=cw)  # image weights
  290.                 dataset.indices = random.choices(range(dataset.n), weights=iw, k=dataset.n)  # rand weighted idx
  291.             # Broadcast if DDP
  292.             if RANK != -1:
  293.                 indices = (torch.tensor(dataset.indices) if RANK == 0 else torch.zeros(dataset.n)).int()
  294.                 dist.broadcast(indices, 0)
  295.                 if RANK != 0:
  296.                     dataset.indices = indices.cpu().numpy()
  297.  
  298.         # Update mosaic border
  299.         # b = int(random.uniform(0.25 * imgsz, 0.75 * imgsz + gs) // gs * gs)
  300.         # dataset.mosaic_border = [b - imgsz, -b]  # height, width borders
  301.  
  302.         mloss = torch.zeros(4, device=device)  # mean losses
  303.         if RANK != -1:
  304.             train_loader.sampler.set_epoch(epoch)
  305.         pbar = enumerate(train_loader)
  306.         LOGGER.info(('\n' + '%10s' * 8) % ('Epoch', 'gpu_mem', 'box', 'obj', 'cls', 'total', 'labels', 'img_size'))
  307.         if RANK in [-1, 0]:
  308.             pbar = tqdm(pbar, total=nb)  # progress bar
  309.         optimizer.zero_grad()
  310.         for i, (imgs, targets, paths, _) in pbar:  # batch -------------------------------------------------------------
  311.             ni = i + nb * epoch  # number integrated batches (since train start)
  312.             imgs = imgs.to(device, non_blocking=True).float() / 255.0  # uint8 to float32, 0-255 to 0.0-1.0
  313.  
  314.             # Warmup
  315.             if ni <= nw:
  316.                 xi = [0, nw]  # x interp
  317.                 # model.gr = np.interp(ni, xi, [0.0, 1.0])  # iou loss ratio (obj_loss = 1.0 or iou)
  318.                 accumulate = max(1, np.interp(ni, xi, [1, nbs / batch_size]).round())
  319.                 for j, x in enumerate(optimizer.param_groups):
  320.                     # bias lr falls from 0.1 to lr0, all other lrs rise from 0.0 to lr0
  321.                     x['lr'] = np.interp(ni, xi, [hyp['warmup_bias_lr'] if j == 2 else 0.0, x['initial_lr'] * lf(epoch)])
  322.                     if 'momentum' in x:
  323.                         x['momentum'] = np.interp(ni, xi, [hyp['warmup_momentum'], hyp['momentum']])
  324.  
  325.             # Multi-scale
  326.             if opt.multi_scale:
  327.                 sz = random.randrange(imgsz * 0.5, imgsz * 1.5 + gs) // gs * gs  # size
  328.                 sf = sz / max(imgs.shape[2:])  # scale factor
  329.                 if sf != 1:
  330.                     ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]]  # new shape (stretched to gs-multiple)
  331.                     imgs = F.interpolate(imgs, size=ns, mode='bilinear', align_corners=False)
  332.  
  333.             # Forward
  334.             with amp.autocast(enabled=cuda):
  335.                 pred = model(imgs)  # forward
  336.                 loss, loss_items = compute_loss(pred, targets.to(device))  # loss scaled by batch_size
  337.                 if RANK != -1:
  338.                     loss *= WORLD_SIZE  # gradient averaged between devices in DDP mode
  339.                 if opt.quad:
  340.                     loss *= 4.
  341.  
  342.             # Backward
  343.             scaler.scale(loss).backward()
  344.  
  345.             # Optimize
  346.             if ni - last_opt_step >= accumulate:
  347.                 scaler.step(optimizer)  # optimizer.step
  348.                 scaler.update()
  349.                 optimizer.zero_grad()
  350.                 if ema:
  351.                     ema.update(model)
  352.                 last_opt_step = ni
  353.  
  354.             # Print
  355.             if RANK in [-1, 0]:
  356.                 mloss = (mloss * i + loss_items) / (i + 1)  # update mean losses
  357.                 mem = '%.3gG' % (torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0)  # (GB)
  358.                 s = ('%10s' * 2 + '%10.4g' * 6) % (
  359.                     f'{epoch}/{epochs - 1}', mem, *mloss, targets.shape[0], imgs.shape[-1])
  360.                 pbar.set_description(s)
  361.  
  362.                 # Plot
  363.                 if plots and ni < 3:
  364.                     f = save_dir / f'train_batch{ni}.jpg'  # filename
  365.                     Thread(target=plot_images, args=(imgs, targets, paths, f), daemon=True).start()
  366.                     if loggers['tb'] and ni == 0:  # TensorBoard
  367.                         with warnings.catch_warnings():
  368.                             warnings.simplefilter('ignore')  # suppress jit trace warning
  369.                             loggers['tb'].add_graph(torch.jit.trace(de_parallel(model), imgs[0:1], strict=False), [])
  370.                 elif plots and ni == 10 and loggers['wandb']:
  371.                     wandb_logger.log({'Mosaics': [loggers['wandb'].Image(str(x), caption=x.name) for x in
  372.                                                   save_dir.glob('train*.jpg') if x.exists()]})
  373.  
  374.             # end batch ------------------------------------------------------------------------------------------------
  375.  
  376.         # Scheduler
  377.         lr = [x['lr'] for x in optimizer.param_groups]  # for loggers
  378.         scheduler.step()
  379.  
  380.         # DDP process 0 or single-GPU
  381.         if RANK in [-1, 0]:
  382.             # mAP
  383.             ema.update_attr(model, include=['yaml', 'nc', 'hyp', 'gr', 'names', 'stride', 'class_weights'])
  384.             final_epoch = epoch + 1 == epochs
  385.             if not noval or final_epoch:  # Calculate mAP
  386.                 wandb_logger.current_epoch = epoch + 1
  387.                 results, maps, _ = val.run(data_dict,
  388.                                            batch_size=batch_size // WORLD_SIZE * 2,
  389.                                            imgsz=imgsz,
  390.                                            model=ema.ema,
  391.                                            single_cls=single_cls,
  392.                                            dataloader=val_loader,
  393.                                            save_dir=save_dir,
  394.                                            save_json=is_coco and final_epoch,
  395.                                            verbose=nc < 50 and final_epoch,
  396.                                            plots=plots and final_epoch,
  397.                                            wandb_logger=wandb_logger,
  398.                                            compute_loss=compute_loss)
  399.  
  400.             # Write
  401.             with open(results_file, 'a') as f:
  402.                 f.write(s + '%10.4g' * 7 % results + '\n')  # append metrics, val_loss
  403.  
  404.             # Log
  405.             tags = ['train/box_loss', 'train/obj_loss', 'train/cls_loss',  # train loss
  406.                     'metrics/precision', 'metrics/recall', 'metrics/mAP_0.5', 'metrics/mAP_0.5:0.95',
  407.                     'val/box_loss', 'val/obj_loss', 'val/cls_loss',  # val loss
  408.                     'x/lr0', 'x/lr1', 'x/lr2']  # params
  409.             for x, tag in zip(list(mloss[:-1]) + list(results) + lr, tags):
  410.                 if loggers['tb']:
  411.                     loggers['tb'].add_scalar(tag, x, epoch)  # TensorBoard
  412.                 if loggers['wandb']:
  413.                     wandb_logger.log({tag: x})  # W&B
  414.  
  415.             # Update best mAP
  416.             fi = fitness(np.array(results).reshape(1, -1))  # weighted combination of [P, R, mAP@.5, mAP@.5-.95]
  417.             if fi > best_fitness:
  418.                 best_fitness = fi
  419.             wandb_logger.end_epoch(best_result=best_fitness == fi)
  420.  
  421.             # Save model
  422.             if (not nosave) or (final_epoch and not evolve):  # if save
  423.                 ckpt = {'epoch': epoch,
  424.                         'best_fitness': best_fitness,
  425.                         'training_results': results_file.read_text(),
  426.                         'model': deepcopy(de_parallel(model)).half(),
  427.                         'ema': deepcopy(ema.ema).half(),
  428.                         'updates': ema.updates,
  429.                         'optimizer': optimizer.state_dict(),
  430.                         'wandb_id': wandb_logger.wandb_run.id if loggers['wandb'] else None}
  431.  
  432.                 # Save last, best and delete
  433.                 torch.save(ckpt, last)
  434.                 if best_fitness == fi:
  435.                     torch.save(ckpt, best)
  436.                 if loggers['wandb']:
  437.                     if ((epoch + 1) % opt.save_period == 0 and not final_epoch) and opt.save_period != -1:
  438.                         wandb_logger.log_model(last.parent, opt, epoch, fi, best_model=best_fitness == fi)
  439.                 del ckpt
  440.  
  441.         # end epoch ----------------------------------------------------------------------------------------------------
  442.     # end training -----------------------------------------------------------------------------------------------------
  443.     if RANK in [-1, 0]:
  444.         LOGGER.info(f'{epoch - start_epoch + 1} epochs completed in {(time.time() - t0) / 3600:.3f} hours.\n')
  445.         if plots:
  446.             plot_results(save_dir=save_dir)  # save as results.png
  447.             if loggers['wandb']:
  448.                 files = ['results.png', 'confusion_matrix.png', *[f'{x}_curve.png' for x in ('F1', 'PR', 'P', 'R')]]
  449.                 wandb_logger.log({"Results": [loggers['wandb'].Image(str(save_dir / f), caption=f) for f in files
  450.                                               if (save_dir / f).exists()]})
  451.  
  452.         if not evolve:
  453.             if is_coco:  # COCO dataset
  454.                 for m in [last, best] if best.exists() else [last]:  # speed, mAP tests
  455.                     results, _, _ = val.run(data_dict,
  456.                                             batch_size=batch_size // WORLD_SIZE * 2,
  457.                                             imgsz=imgsz,
  458.                                             model=attempt_load(m, device).half(),
  459.                                             single_cls=single_cls,
  460.                                             dataloader=val_loader,
  461.                                             save_dir=save_dir,
  462.                                             save_json=True,
  463.                                             plots=False)
  464.  
  465.             # Strip optimizers
  466.             for f in last, best:
  467.                 if f.exists():
  468.                     strip_optimizer(f)  # strip optimizers
  469.             if loggers['wandb']:  # Log the stripped model
  470.                 loggers['wandb'].log_artifact(str(best if best.exists() else last), type='model',
  471.                                               name='run_' + wandb_logger.wandb_run.id + '_model',
  472.                                               aliases=['latest', 'best', 'stripped'])
  473.         wandb_logger.finish_run()
  474.  
  475.     torch.cuda.empty_cache()
  476.     return results

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/150930
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号