Datawhale — cv方向 task 1 笔记-CSDN博客

本文链接：https://blog.csdn.net/2301_79387683/article/details/141462960

针对 cv 方向的 task 1 记录了一点教程之外的东西

教程：Datawhale

教程里很详细，只在做的过程中几个小瞬间记录一下（可以直接划到后面开始阅读哦）

Task 1

Task 1 碎片化记录

1 . Task 1 学习规划

2 . 赛事官网打卡

3 . 教程 step 2 中进行第 2 步租用4090时点击新建会需要个人认证一下哦

4 . 创建上啦

5 . 可以使用啦

6 . baseline相关文件下载完成

6 . 看赛题

7 . 上传结果了

等~~

8 . 初次跑 baseline 提交代码的成绩出来啦

赛题纵览

教程教我们看看赛题

一般情况下，拿到一个赛题之后，我们需要明确：

1）这是一个什么场景下的赛题；

2）这个赛题要解决什么问题。

视频物体检测问题

本赛题最终目标是开发一套智能识别系统，能够自动检测和分类城市管理中的违规行为。该系统应利用先进的图像处理和计算机视觉技术，通过对摄像头捕获的视频进行分析，自动准确识别违规行为，并及时向管理部门发出告警，以实现更高效的城市管理。

教程中有对赛题进行剖析，在此不做过多赘述。

代码解析

对这中间涉及的代码进行一些解析

1. 下载baseline相关文件

apt install git-lfs
git lfs install
git clone https://www.modelscope.cn/datasets/Datawhale/AI_Camp5_baseline_CV.git

作用：安装 Git LFS（Large File Storage）并克隆一个 Git 仓库

实现步骤：

安装 Git LFS:
- 运行 apt install git-lfs 以安装 Git LFS。
- 运行 git lfs install 以安装 Git LFS 的钩子。
克隆 Git 仓库:
- 运行 git clone https://www.modelscope.cn/datasets/Datawhale/AI_Camp5_baseline_CV.git 以克隆仓库。

2 . baseline 内部代码

!/opt/miniconda/bin/pip install opencv-python pandas matplotlib ultralytics

在Anaconda 环境中安装四个 Python 包：opencv-python、pandas、matplotlib 和 ultralytics

科普：

opencv-python: OpenCV 的 Python 接口，用于计算机视觉任务。
pandas: 用于数据分析的强大库。
matplotlib: 用于绘制图表和图形的库。
ultralytics: 一个轻量级的框架，用于训练和部署 YOLOv8 模型，这是一个流行的物体检测模型

通常用于数据分析、图像处理、绘图和机器学习任务

import os, sys
import cv2, glob, json
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

导入了Python中的几个库，为进行图像处理、数据分析和绘图等工作做了准备

!apt install zip unzip -y
!apt install unar -y

在Linux环境中安装压缩和解压文件所需的工具

!wget "https://comp-public-prod.obs.cn-east-3.myhuaweicloud.com/dataset/2024/%E8%AE%AD%E7%BB%83%E9%9B%86%28%E6%9C%89%E6%A0%87%E6%B3%A8%E7%AC%AC%E4%B8%80%E6%89%B9%29.zip?AccessKeyId=583AINLNMLDRFK7CC1YM&Expires=1739168844&Signature=9iONBSJORCS8UNr2m/VZnc7yYno%3D" -O 训练集\(有标注第一批\).zip
!unar -q 训练集\(有标注第一批\).zip

这段代码的目的是从指定的URL下载一个压缩文件训练集(有标注第一批).zip ，并将其解压到当前目录

!wget "https://comp-public-prod.obs.cn-east-3.myhuaweicloud.com/dataset/2024/%E6%B5%8B%E8%AF%95%E9%9B%86.zip?AccessKeyId=583AINLNMLDRFK7CC1YM&Expires=1739168909&Signature=CRsB54VqOtrzIdUHC3ay0l2ZGNw%3D" -O 测试集.zip
!unar -q 测试集.zip

这段代码的目的是从指定的URL下载一个压缩文件测试集.zip ，并将其解压到当前目录

train_anno = json.load(open('训练集(有标注第一批)/标注/45.json', encoding='utf-8'))
train_anno[0], len(train_anno)

加载一个名为 '训练集(有标注第一批)/标注/45.json' 的 JSON 文件，并将其内容解析为一个 Python 字典，然后尝试获取这个字典的第一个元素，并计算字典中的键值对数量

pd.read_json('训练集(有标注第一批)/标注/45.json')

用 Pandas 库中的 read_json() 方法来读取一个 JSON 文件，并将其内容转换为 Pandas DataFrame 对象

video_path = '训练集(有标注第一批)/视频/45.mp4'
cap = cv2.VideoCapture(video_path)
while True:
    # 读取下一帧
    ret, frame = cap.read()
    if not ret:
        break
    break

从一个视频文件中读取并处理每一帧

步骤：

1 . 设置变量 video_path 为视频文件的路径

2 . 使用 OpenCV 的 VideoCapture 类来打开视频文件

3 . 进入一个无限循环（while True:）

在循环内部，使用 cap.read() 方法读取视频的下一帧

如果 ret 为 False，说明已经到达视频末尾或读取出现错误，此时使用 break 语句退出循环。

无论何时，只要读取了一帧，就会使用第二个 break 语句立即退出循环。

由此想到，如果要显示每一帧，代码应该如下：（按 q 键退出循环）

video_path = '训练集(有标注第一批)/视频/45.mp4'
cap = cv2.VideoCapture(video_path)

while True:
    # 读取下一帧
    ret, frame = cap.read()
    
    if not ret:
        break
        
    # 显示当前帧
    cv2.imshow('Frame', frame)
    
    # 检查是否有按键按下
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放资源
cap.release()
cv2.destroyAllWindows()

思路回来，接着跟着示例代码

frame.shape

frame.shape 返回这个数组的维度信息

int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

获取视频文件中的总帧数

bbox = [746, 494, 988, 786]

pt1 = (bbox[0], bbox[1])
pt2 = (bbox[2], bbox[3])

color = (0, 255, 0) 
thickness = 2  # 线条粗细

cv2.rectangle(frame, pt1, pt2, color, thickness)

frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
plt.imshow(frame)

在图像 frame 上绘制一个绿色矩形框，并使用 Matplotlib 显示带有矩形框的图像

解释：

bbox: 一个列表，包含了矩形框的坐标信息。列表中的元素依次表示左上角的 x 坐标、左上角的 y 坐标、右下角的 x 坐标和右下角的 y 坐标。
pt1: 一个元组，表示矩形框左上角的坐标。
pt2: 一个元组，表示矩形框右下角的坐标。
color: 一个元组，表示绘制矩形框的颜色。这里使用的是绿色，表示为 (0, 255, 0)，其中 0 表示蓝色通道强度，255 表示绿色通道强度，0 表示红色通道强度。
thickness: 一个整数，表示绘制矩形框线条的粗细程度。
cv2.rectangle(): OpenCV 中用于在图像上绘制矩形的函数。
cv2.cvtColor(): OpenCV 中用于转换图像颜色空间的函数。
cv2.COLOR_BGR2RGB: 颜色空间转换的标志，表示将图像从 BGR（蓝绿红）颜色空间转换为 RGB（红绿蓝）颜色空间。这是因为 OpenCV 默认使用 BGR 颜色空间，而 Matplotlib 默认使用 RGB 颜色空间。
plt.imshow(): Matplotlib 的一个函数，用于显示图像。

if not os.path.exists('yolo-dataset/'):
    os.mkdir('yolo-dataset/')
if not os.path.exists('yolo-dataset/train'):
    os.mkdir('yolo-dataset/train')
if not os.path.exists('yolo-dataset/val'):
    os.mkdir('yolo-dataset/val')

dir_path = os.path.abspath('./') + '/'

# 需要按照你的修改path
with open('yolo-dataset/yolo.yaml', 'w', encoding='utf-8') as up:
    up.write(f'''
path: {dir_path}/yolo-dataset/
train: train/
val: val/

names:
    0: 非机动车违停
    1: 机动车违停
    2: 垃圾桶满溢
    3: 违法经营
''')

创建了一个用于YOLO（You Only Look Once）目标检测模型的数据集目录结构，并写入了一个配置文件 (yolo.yaml)，用于指定训练和验证数据集的位置以及类别名称

代码解释：

os.path.exists('yolo-dataset/'): 检查 'yolo-dataset/' 目录是否存在。
os.mkdir('yolo-dataset/'): 如果 'yolo-dataset/' 目录不存在，则创建它。
检查 'yolo-dataset/train' 目录是否存在。
如果不存在，创建 'yolo-dataset/train' 目录。
检查 'yolo-dataset/val' 目录是否存在。
如果不存在，创建 'yolo-dataset/val' 目录。
os.path.abspath('./'): 获取当前工作目录的绝对路径。
+ '/': 在路径后面加上斜杠，使其成为 './absolute/path/to/current/directory/' 的形式
open('yolo-dataset/yolo.yaml', 'w', encoding='utf-8'): 以写入模式 ('w') 打开 'yolo-dataset/yolo.yaml' 文件，并指定编码为 'utf-8'。
with ... as up: 使用 with 语句确保文件在操作完成后被正确关闭。
up.write(): 写入配置文件的内容。
- path: {dir_path}yolo-dataset/: 指定数据集的根目录。
- train: train/: 指定训练数据集的位置。
- val: val/: 指定验证数据集的位置。
- names:: 指定类别名称。

用于准备数据集以供YOLO模型训练或测试使用

train_annos = glob.glob('训练集(有标注第一批)/标注/*.json')
train_videos = glob.glob('训练集(有标注第一批)/视频/*.mp4')
train_annos.sort(); train_videos.sort();

category_labels = ["非机动车违停", "机动车违停", "垃圾桶满溢", "违法经营"]

收集训练数据集中的标注文件和视频文件，并对它们进行排序；还定义了一个列表，包含了训练数据集中涉及的类别标签

代码解释：

glob.glob(): 用于查找符合特定规则的文件路径名，这里查找的是 '训练集(有标注第一批)/标注/' 目录下所有 .json 文件。
train_annos: 存储找到的所有标注文件的路径列表。
glob.glob(): 用于查找符合特定规则的文件路径名，这里查找的是 '训练集(有标注第一批)/视频/' 目录下所有 .mp4 文件。
train_videos: 存储找到的所有视频文件的路径列表。
sort(): 用于对列表中的元素进行排序。
category_labels: 定义了一个列表，包含了训练数据集中涉及的四个类别的标签。

for anno_path, video_path in zip(train_annos[:5], train_videos[:5]):
    print(video_path)
    anno_df = pd.read_json(anno_path)
    cap = cv2.VideoCapture(video_path)
    frame_idx = 0 
    while True:
        ret, frame = cap.read()
        if not ret:
            break

        img_height, img_width = frame.shape[:2]
        
        frame_anno = anno_df[anno_df['frame_id'] == frame_idx]
        cv2.imwrite('./yolo-dataset/train/' + anno_path.split('/')[-1][:-5] + '_' + str(frame_idx) + '.jpg', frame)

        if len(frame_anno) != 0:
            with open('./yolo-dataset/train/' + anno_path.split('/')[-1][:-5] + '_' + str(frame_idx) + '.txt', 'w') as up:
                for category, bbox in zip(frame_anno['category'].values, frame_anno['bbox'].values):
                    category_idx = category_labels.index(category)
                    
                    x_min, y_min, x_max, y_max = bbox
                    x_center = (x_min + x_max) / 2 / img_width
                    y_center = (y_min + y_max) / 2 / img_height
                    width = (x_max - x_min) / img_width
                    height = (y_max - y_min) / img_height

                    if x_center > 1:
                        print(bbox)
                    up.write(f'{category_idx} {x_center} {y_center} {width} {height}\n')
        
        frame_idx += 1

从训练数据集中提取视频帧，并为每一帧创建对应的标注文件

代码解释：

zip(train_annos[:5], train_videos[:5]): 使用 zip() 将 train_annos 和 train_videos 列表的前五个元素配对，每次迭代返回一个标注文件路径和一个视频文件路径。
打印当前处理的视频文件路径。
使用 pd.read_json() 函数读取标注文件，并将其内容转换为 Pandas DataFrame。
使用 cv2.VideoCapture() 打开视频文件。
初始化帧索引。
循环读取视频中的每一帧，直到 cap.read() 返回 False（表示到达视频末尾或发生错误）。
获取当前帧的高度和宽度。
从标注 DataFrame 中筛选出与当前帧索引相对应的标注信息。
将当前帧保存为 JPEG 图像文件，文件名由标注文件名（去除扩展名）和帧索引组成。
如果当前帧有标注信息，则创建一个对应的标注文件，并将每个标注的类别索引和归一化边界框坐标写入文件。
- category_labels.index(category): 获取类别的索引。
- 归一化边界框坐标：将边界框的中心坐标和宽高转换为相对于图像宽度和高度的比例。
- 如果归一化后的中心坐标 x_center 大于 1，则打印边界框坐标。
- 将类别索引和归一化的边界框坐标写入标注文件。
更新帧索引。

for anno_path, video_path in zip(train_annos[-3:], train_videos[-3:]):
    print(video_path)
    anno_df = pd.read_json(anno_path)
    cap = cv2.VideoCapture(video_path)
    frame_idx = 0 
    while True:
        ret, frame = cap.read()
        if not ret:
            break

        img_height, img_width = frame.shape[:2]
        
        frame_anno = anno_df[anno_df['frame_id'] == frame_idx]
        cv2.imwrite('./yolo-dataset/val/' + anno_path.split('/')[-1][:-5] + '_' + str(frame_idx) + '.jpg', frame)

        if len(frame_anno) != 0:
            with open('./yolo-dataset/val/' + anno_path.split('/')[-1][:-5] + '_' + str(frame_idx) + '.txt', 'w') as up:
                for category, bbox in zip(frame_anno['category'].values, frame_anno['bbox'].values):
                    category_idx = category_labels.index(category)
                    
                    x_min, y_min, x_max, y_max = bbox
                    x_center = (x_min + x_max) / 2 / img_width
                    y_center = (y_min + y_max) / 2 / img_height
                    width = (x_max - x_min) / img_width
                    height = (y_max - y_min) / img_height

                    up.write(f'{category_idx} {x_center} {y_center} {width} {height}\n')
        
        frame_idx += 1

这段代码用于从训练数据集中提取视频帧，并为每一帧创建对应的标注文件，这里是针对最后三个视频文件和对应的标注文件进行处理

代码解释：

zip(train_annos[-3:], train_videos[-3:]): 使用zip() 将 train_annos 和 train_videos 列表的最后三个元素配对，每次迭代返回一个标注文件路径和一个视频文件路径。

其余代码基本同上一段

!wget http://mirror.coggle.club/yolo/yolov8n-v8.2.0.pt -O yolov8n.pt\

从指定的 URL 下载 YOLOv8n 模型的预训练权重文件，并将其保存为本地文件 yolov8n.pt

!mkdir -p ~/.config/Ultralytics/
!wget http://mirror.coggle.club/yolo/Arial.ttf -O ~/.config/Ultralytics/Arial.ttf

创建一个目录 ~/.config/Ultralytics/ 并下载一个字体文件 Arial.ttf 到该目录中

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

import warnings
warnings.filterwarnings('ignore')

设置环境变量 CUDA_VISIBLE_DEVICES 为 "0"，使得 CUDA 只能看到编号为 0 的 GPU 设备；忽略所有警告消息，这样在运行过程中不会看到警告输出

from ultralytics import YOLO
model = YOLO("yolov8n.pt")
results = model.train(data="yolo-dataset/yolo.yaml", epochs=2, imgsz=1080, batch=16)

用 Ultralytics 的 YOLO 库来训练一个目标检测模型

代码解释：

导入 Ultralytics 库中的 YOLO 类，用于创建和训练 YOLO 模型的主要接口。
创建一个 YOLO 模型实例，使用预训练的权重文件 "yolov8n.pt"。
使用 model.train() 方法开始训练过程。
- data: 指定数据配置文件的路径， "yolo-dataset/yolo.yaml"，该文件包含了训练和验证数据集的位置以及类别名称等信息。
- epochs: 指定训练的轮次， 2，意味着模型将在整个训练数据集上迭代两次。
- imgsz: 指定输入图像的大小， 1080，这意味着模型将接收分辨率为 1080 的图像。
- batch: 指定每批训练样本的数量， 16。

category_labels = ["非机动车违停", "机动车违停", "垃圾桶满溢", "违法经营"]

if not os.path.exists('result/'):
    os.mkdir('result')

定义了一个列表 category_labels，包含了类别标签，创建了一个名为 result/ 的目录（如果它还不存在的话）

from ultralytics import YOLO
model = YOLO("runs/detect/train/weights/best.pt")
import glob

for path in glob.glob('测试集/*.mp4'):
    submit_json = []
    results = model(path, conf=0.05, imgsz=1080,  verbose=False)
    for idx, result in enumerate(results):
        boxes = result.boxes  # Boxes object for bounding box outputs
        masks = result.masks  # Masks object for segmentation masks outputs
        keypoints = result.keypoints  # Keypoints object for pose outputs
        probs = result.probs  # Probs object for classification outputs
        obb = result.obb  # Oriented boxes object for OBB outputs

        if len(boxes.cls) == 0:
            continue
        
        xywh = boxes.xyxy.data.cpu().numpy().round()
        cls = boxes.cls.data.cpu().numpy().round()
        conf = boxes.conf.data.cpu().numpy()
        for i, (ci, xy, confi) in enumerate(zip(cls, xywh, conf)):
            submit_json.append(
                {
                    'frame_id': idx,
                    'event_id': i+1,
                    'category': category_labels[int(ci)],
                    'bbox': list([int(x) for x in xy]),
                    "confidence": float(confi)
                }
            )

    with open('./result/' + path.split('/')[-1][:-4] + '.json', 'w', encoding='utf-8') as up:
        json.dump(submit_json, up, indent=4, ensure_ascii=False)

使用 Ultralytics 的 YOLO 库来对一系列测试视频进行目标检测，并将检测结果保存为 JSON 文件，每个 JSON 文件包含了每个帧的检测结果，包括帧索引、事件 ID、类别名称、边界框坐标和置信度

代码解释：

导入 Ultralytics 库中的 YOLO 类。
创建一个 YOLO 模型实例，使用预训练的权重文件 "runs/detect/train/weights/best.pt"。
导入 glob 模块，它用于查找符合特定规则的文件路径名列表。
使用 glob.glob() 函数查找 '测试集/' 目录下所有 .mp4 文件，并对每个视频文件进行处理。
初始化一个空列表 submit_json，用于存储每个视频的检测结果。
使用 model() 方法对视频文件 path 进行目标检测。
- conf=0.05: 设置置信度阈值为 0.05，即低于此阈值的目标将被忽略。
- imgsz=1080: 设置输入图像的大小为 1080。
- verbose=False: 不显示详细的输出信息。

遍历 results 中的每一个检测结果，idx 表示结果的索引，result 包含单帧的检测信息。
result.boxes: 包含边界框输出的对象。
result.masks: 包含分割掩码输出的对象。
result.keypoints: 包含关键点输出的对象。
result.probs: 包含分类概率输出的对象。
result.obb: 包含定向边界框输出的对象。
检查是否有检测到的目标。如果没有检测到任何目标，则跳过当前帧。
xywh: 包含检测到的目标的边界框坐标，形式为 [x1, y1, x2, y2]。
cls: 包含每个目标的类别索引。
conf: 包含每个目标的置信度。
遍历每个检测到的目标及其边界框坐标、类别索引和置信度。
将检测结果添加到 submit_json 列表中，包括帧索引、事件 ID、类别名称、边界框坐标和置信度。
使用 json.dump() 将 submit_json 列表保存为 JSON 文件。
- 文件名由视频文件名（去除扩展名）组成，并保存在 ./result/ 目录下。
- indent=4: 以缩进的方式格式化输出的 JSON 文件，便于阅读。
- ensure_ascii=False: 允许在 JSON 文件中使用非 ASCII 字符，如中文字符。

!\rm result/.ipynb_checkpoints/ -rf
!\rm result.zip
!zip -r result.zip result/

清理和打包文件

YOLO

什么是YOLO？什么是物体检测模型？

从教程上摘了点知识：

YOLO，全称为“You Only Look Once”（你只看一眼），是一种流行的实时目标检测系统，由Joseph Redmon等人在2015年提出。YOLO模型的核心思想是将目标检测任务视为一个单一的回归问题，通过一个卷积神经网络（CNN）直接从图像像素到边界框坐标和类别概率的映射。YOLO模型经过了多次迭代，包括YOLOv2（YOLO9000）、YOLOv3和YOLOv4等版本，每个版本都在性能和速度上有所提升，同时也引入了一些新的技术，如更深的网络结构、更好的锚框机制、多尺度特征融合等。