企业官网建设流程全解析

这几年在参与中华白海豚相关影像资料整理时，最大的感触是：视频素材动辄几十个小时，但真正拍到白海豚的片段可能只占几分钟。人工逐帧去找，既费眼睛又容易漏掉关键画面。后来我们逐步把“目标检测 + 视频拆帧 + 结果过滤”这套流程落地，才发现“没有白海豚就没有这个视频”这个判断，其实可以交给算法来做。这篇文章就把这套从海量视频中自动截取白海豚片段的完整方案整理出来，包含环境搭建、模型训练、视频推理和常见报错排查，希望给正在做野生动物影像分析、海洋监测或视频自动剪辑的朋友一些参考。

1. 背景与核心概念

1.1 为什么要用算法识别视频中的白海豚

中华白海豚是国家一级保护动物，通常栖息在河口和近岸海域。野外监测和纪录片拍摄过程中，常用无人机、船载摄像头或水下摄影机长时间连续录制。这样会产生大量视频素材，而白海豚的出现往往没有固定时间规律，可能一整天的素材里只有几段有效画面。

人工处理这些素材的工作量非常大。比如一段 8 小时的 4K 视频，如果按每秒 25 帧计算，大约有 72 万帧画面，逐帧浏览几乎不现实。即使用快进方式预览，也很容易错过白海豚浮出水面的瞬间。于是“自动找出包含白海豚的视频片段”就成了一个很现实的工程问题。

1.2 从视频中提取目标片段的核心思路

这个问题的本质是“视频中的目标检测与时间片段定位”。整体流程可以拆成三个阶段：

1. 视频拆帧：把连续视频转换成帧图片，并记录每帧对应的时间点。
2. 目标检测：用训练好的目标检测模型判断每一帧中是否出现白海豚，并给出置信度分数。
3. 片段合并：把连续出现白海豚的帧合并成时间片段，再从原始视频中截取出对应的视频段落。

目标检测部分采用 YOLO 系列模型。YOLO 的核心思想是把目标检测当成回归问题，一次前向推理同时预测目标类别和边界框位置。相比两阶段检测器，YOLO 在视频场景下速度优势明显，更适合处理大规模视频数据。

1.3 适用场景

这套方案不局限于白海豚，同样适用于江豚、鲸类、鸟类、大型海洋生物等野生动物影像分析。任何需要“从长视频中找出特定目标出现片段”的需求，都可以复用同一套技术框架。

2. 环境准备与版本说明

2.1 开发环境清单

先列出本次实战使用的运行环境。版本需要根据你的项目实际情况调整，本文示例以常见环境为例，重点演示配置思路。

2.2 安装依赖

建议先创建独立的 Python 虚拟环境，避免和系统环境或其他项目冲突。

conda create -n dolphin python=3.10 conda activate dolphin

安装 PyTorch 时，需要根据你的 CUDA 版本选择合适的安装命令。如果暂时没有 GPU，也可以安装 CPU 版本用于流程验证，但视频处理速度会明显偏慢。

# CPU 版本 pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu # GPU 版本，请先查看本机 CUDA 版本，示例以 CUDA 11.8 为例 pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118

然后安装目标检测库和视频处理相关依赖。

pip install ultralytics opencv-python

安装完成后，可以输入下面命令验证 Ultralytics 是否正常。

python -c "from ultralytics import YOLO; print('YOLO OK')"

如果输出YOLO OK，说明环境已经就绪。

2.3 推荐项目结构

建议按照下面的目录结构组织代码和数据。

dolphin_video/ ├── data/ │ ├── images/ │ │ ├── train/ │ │ └── val/ │ ├── labels/ │ │ ├── train/ │ │ └── val/ │ └── dolphin.yaml ├── models/ │ └── best.pt ├── input/ │ └── raw_video.mp4 ├── output/ │ ├── clips/ │ └── frames/ ├── scripts/ │ ├── extract_frames.py │ ├── train.py │ ├── detect_video.py │ └── merge_clips.py └── requirements.txt

data/images存放训练图片，data/labels存放对应的 YOLO 格式标注文件，models保存训练好的权重，input放待处理的视频，output放检测结果和截取片段。

3. 核心语法、配置与原理拆解

3.1 视频拆帧与时间戳记录

视频处理的第一步是拆帧。为什么不能直接拿视频文件去做检测？因为目标检测模型通常处理的是单张图片，需要把视频流逐帧暴露给模型。同时，每个帧必须对应一个时间点，后续合并片段时才能准确还原到原始视频上。

下面是一个拆帧脚本的核心片段，工作逻辑是：用 OpenCV 读取视频，循环读取每一帧，保存为 JPG 图片，并记录帧序号和时间戳。

# 文件路径：scripts/extract_frames.py import cv2 import os import time def extract_frames(video_path, output_dir, frame_step=1): os.makedirs(output_dir, exist_ok=True) cap = cv2.VideoCapture(video_path) fps = cap.get(cv2.CAP_PROP_FPS) total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) print(f"视频帧率: {fps:.2f}, 总帧数: {total_frames}") frame_idx = 0 saved_idx = 0 timestamp_file = os.path.join(output_dir, "timestamps.txt") with open(timestamp_file, "w", encoding="utf-8") as f: while True: ret, frame = cap.read() if not ret: break if frame_idx % frame_step == 0: timestamp = frame_idx / fps frame_path = os.path.join(output_dir, f"frame_{saved_idx:06d}.jpg") cv2.imwrite(frame_path, frame) f.write(f"frame_{saved_idx:06d}.jpg {timestamp:.3f}\n") saved_idx += 1 frame_idx += 1 cap.release() print(f"共提取 {saved_idx} 帧，时间戳已保存到 {timestamp_file}") if __name__ == "__main__": extract_frames("input/raw_video.mp4", "output/frames")

几个关键点：

• frame_step表示每隔多少帧保存一次。如果视频帧率是 30，frame_step=1表示每秒保存 30 帧，检测压力较大；frame_step=3表示每秒保存 10 帧，速度更快但可能漏掉快速游动的目标。
• 时间戳frame_idx / fps是这一帧在视频中的绝对时间位置，单位是秒。后续合并片段和截取视频都依赖这个值。
• timestamps.txt是帧文件名和时间戳的映射关系，建议保留下来，方便回溯。

3.2 YOLO 数据集标注与配置

目标检测模型需要带标注的图片数据集。每张图片的标注文件是 TXT 格式，每一行表示一个目标：

类别编号 中心点x 中心点y 宽度 高度

坐标值都是相对于图片宽高的归一化数值，取值范围在 0 到 1 之间。比如一张 1920x1080 的图片上，白海豚边界框中心点在 (960, 540)，宽 500，高 300，那么标注内容就是：

0 0.5 0.5 0.2604 0.2778

其中0.2604 = 500 / 1920，0.2778 = 300 / 1080。

然后需要写一个 YOLO 数据配置文件，告诉模型训练时去哪里找图片和标注文件。文件路径如下：

# 文件路径：data/dolphin.yaml train: data/images/train val: data/images/val nc: 1 names: ['dolphin']

train和val分别指定训练集和验证集图片所在的目录。nc是类别数量，这里只有白海豚一个类别。names是类别名称列表。

3.3 模型训练核心参数

在 Ultralytics YOLO 中，训练入口非常简单，但参数的含义需要理解。

# 文件路径：scripts/train.py from ultralytics import YOLO # 加载预训练模型，这里以 YOLOv8s 为例 model = YOLO("yolov8s.pt") # 开始训练 model.train( data="data/dolphin.yaml", epochs=100, imgsz=640, batch=8, device=0, workers=4, patience=20, project="runs/dolphin", name="exp01" )

参数说明：

• data：指定数据配置文件路径。
• epochs：训练轮数。数据集小的时候 100 轮左右通常足够。
• imgsz：输入图片尺寸。640 是速度与精度比较平衡的默认值。
• batch：批大小。根据显存调整，显存不足时降低到 4 或 2。
• device：0表示使用第一块 GPU，cpu表示使用 CPU。
• workers：数据加载线程数。
• patience：早停策略，连续 N 轮验证集指标没有提升就停止训练。
• project和name：控制训练结果保存目录。

训练结束后，会在runs/dolphin/exp01/weights/目录下生成best.pt和last.pt。best.pt是验证集表现最好的权重，后续检测和截取都使用这个文件。

3.4 目标检测与置信度过滤

训练完成后，可以用 YOLO 模型对图片做推理。推理阶段的重点不只是“检测到有没有目标”，而是要拿到目标的类别、置信度和边界框坐标，然后按照置信度阈值过滤低质量结果。

from ultralytics import YOLO model = YOLO("models/best.pt") results = model.predict("output/frames/frame_000000.jpg", conf=0.5, verbose=False) for result in results: boxes = result.boxes if boxes is not None and len(boxes) > 0: for box in boxes: x1, y1, x2, y2 = box.xyxy[0].tolist() conf = float(box.conf[0]) cls = int(box.cls[0]) print(f"坐标: ({x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f}), 置信度: {conf:.2f}")

conf=0.5表示只保留置信度大于 0.5 的检测结果。置信度阈值直接影响漏检和误检的平衡，如果是文档片段的粗筛，0.3 到 0.5 都可以；如果是正式科研统计，建议调高到 0.6 以上，并且配合人工复核。

3.5 连续帧合并成视频片段

单帧检测结果只是一堆“哪一帧有白海豚”的布尔值。我们需要的是一段连续的时间区间，比如“从 00:12:35 到 00:12:48”。这就要做连续帧合并。

思路是：

1. 遍历所有帧的检测结果，记录有目标出现的帧序号。
2. 如果连续出现的帧之间没有断开，就认为是同一个片段。
3. 允许一定帧数的断档，避免因为模型偶尔漏检导致片段被切断。
4. 设置最短片段长度，过滤掉只有一两帧的误检片段。

下面是一个简化版合并逻辑：

def merge_detections(detected_frames, max_gap=15, min_clip_len=30): """ detected_frames: 已按时间排序的有目标帧序号列表 max_gap: 允许断开的帧数 min_clip_len: 片段最少帧数 """ clips = [] start = detected_frames[0] prev = detected_frames[0] for idx in detected_frames[1:]: if idx - prev > max_gap: if prev - start >= min_clip_len: clips.append((start, prev)) start = idx prev = idx if prev - start >= min_clip_len: clips.append((start, prev)) return clips

这里的detected_frames是“帧序号”列表，不是时间戳。合并后再根据帧率转换回时间，从原始视频中截取片段。

4. 完整实战案例

4.1 创建项目结构

先在项目根目录下创建必要的文件夹。

mkdir -p data/images/train data/images/val data/labels/train data/labels/val mkdir -p models input output/clips output/frames scripts runs

然后把需要处理的视频放到input目录下，把标注好的图片和标注文件按目录放好。

4.2 统一文件名规范

图片和标注文件必须保持文件名一致，只是扩展名不同。比如dolphin_001.jpg对应的标注文件是dolphin_001.txt。这是 YOLO 数据加载的基本要求。建议用下面脚本检查数据集是否对齐：

import os image_dir = "data/images/train" label_dir = "data/labels/train" images = set(os.path.splitext(f)[0] for f in os.listdir(image_dir) if f.endswith(".jpg")) labels = set(os.path.splitext(f)[0] for f in os.listdir(label_dir) if f.endswith(".txt")) missing_labels = images - labels missing_images = labels - images print(f"缺标注的图片: {missing_labels if missing_labels else '无'}") print(f"缺图片的标注: {missing_images if missing_images else '无'}")

4.3 训练目标检测模型

直接运行训练脚本。如果你的数据集较小，建议使用预训练权重yolov8s.pt做迁移学习，这样收敛更快，泛化能力也更好。

python scripts/train.py

训练过程中可以观察损失变化和验证集指标。训练完成后，查看runs/dolphin/exp01/目录，里面会有results.png、confusion_matrix.png、weights/best.pt等文件。把best.pt复制到models/目录下备用。

cp runs/dolphin/exp01/weights/best.pt models/best.pt

4.4 编写视频检测与片段截取脚本

现在进入最关键的环节：输入一段原始视频，输出多个包含白海豚的片段。下面是一个完整可运行的脚本。

# 文件路径：scripts/detect_video.py import cv2 import os import subprocess from ultralytics import YOLO # ========== 配置区 ========== VIDEO_PATH = "input/raw_video.mp4" OUTPUT_DIR = "output/clips" FRAME_OUTPUT_DIR = "output/frames" MODEL_PATH = "models/best.pt" CONF_THRESHOLD = 0.5 MAX_GAP = 15 # 允许断档帧数 MIN_CLIP_FRAMES = 30 # 片段最短帧数 FRAME_STEP = 1 # 每隔多少帧检测一次 # ============================ def extract_frames_with_ts(video_path, output_dir, frame_step): os.makedirs(output_dir, exist_ok=True) cap = cv2.VideoCapture(video_path) fps = cap.get(cv2.CAP_PROP_FPS) frame_idx = 0 saved_idx = 0 frame_list = [] while True: ret, frame = cap.read() if not ret: break if frame_idx % frame_step == 0: frame_path = os.path.join(output_dir, f"frame_{saved_idx:06d}.jpg") cv2.imwrite(frame_path, frame) frame_list.append(frame_path) saved_idx += 1 frame_idx += 1 cap.release() return frame_list, fps def detect_frames(model, frame_list, conf_threshold): detected = [] for i, frame_path in enumerate(frame_list): results = model.predict(frame_path, conf=conf_threshold, verbose=False) for result in results: boxes = result.boxes if boxes is not None and len(boxes) > 0: detected.append(i) break # 只要这一帧有目标就记录 if i % 500 == 0: print(f"已检测 {i}/{len(frame_list)} 帧") return detected def merge_detections(detected, max_gap, min_clip_frames): if not detected: return [] clips = [] start = detected[0] prev = detected[0] for idx in detected[1:]: if idx - prev > max_gap: if prev - start >= min_clip_frames: clips.append((start, prev)) start = idx prev = idx if prev - start >= min_clip_frames: clips.append((start, prev)) return clips def cut_clips(video_path, clips, frame_list, fps, output_dir): os.makedirs(output_dir, exist_ok=True) cap = cv2.VideoCapture(video_path) original_fps = cap.get(cv2.CAP_PROP_FPS) for clip_idx, (start, end) in enumerate(clips): start_time = start / fps end_time = end / fps start_path = frame_list[start] end_path = frame_list[end] output_path = os.path.join(output_dir, f"clip_{clip_idx:03d}.mp4") print(f"片段 {clip_idx}: {start_time:.2f}s -> {end_time:.2f}s") # 使用 ffmpeg 从原始视频中截取时间片段 cmd = [ "ffmpeg", "-y", "-i", video_path, "-ss", f"{start_time:.3f}", "-t", f"{end_time - start_time:.3f}", "-c:v", "libx264", "-c:a", "aac", output_path ] subprocess.run(cmd, capture_output=True) cap.release() if __name__ == "__main__": print("步骤1: 拆帧...") frame_list, fps = extract_frames_with_ts(VIDEO_PATH, FRAME_OUTPUT_DIR, FRAME_STEP) print(f"完成，共 {len(frame_list)} 帧，帧率 {fps:.2f}") print("步骤2: 加载模型...") model = YOLO(MODEL_PATH) print("步骤3: 逐帧检测...") detected = detect_frames(model, frame_list, CONF_THRESHOLD) print(f"检测到有白海豚的帧数: {len(detected)}") print("步骤4: 合并片段...") clips = merge_detections(detected, MAX_GAP, MIN_CLIP_FRAMES) print(f"合并出 {len(clips)} 个片段") print("步骤5: 截取视频...") cut_clips(VIDEO_PATH, clips, frame_list, fps, OUTPUT_DIR) print(f"完成，片段保存在 {OUTPUT_DIR}")

脚本内部逻辑分成五步：

1. 拆帧并保存帧图片，得到有序的帧路径列表。
2. 加载训练好的 YOLO 模型。
3. 逐帧检测，只记录“出现白海豚”的帧索引。
4. 对检测结果做合并，形成连续片段。
5. 调用 ffmpeg 从原始视频中截取对应时间段，生成独立的视频文件。

4.5 运行与验证

在运行截取脚本之前，确保系统已经安装 ffmpeg。如果没有安装，可以用系统包管理器安装：

# Ubuntu sudo apt install ffmpeg # macOS brew install ffmpeg # Windows 请到 ffmpeg 官网下载并添加到 PATH

然后运行脚本：

python scripts/detect_video.py

正常情况下会输出类似下面的日志：

步骤1: 拆帧... 视频帧率: 30.00, 总帧数: 216000 完成，共 216000 帧，帧率 30.00 步骤2: 加载模型... 步骤3: 逐帧检测... 已检测 0/216000 帧 已检测 500/216000 帧 ... 检测到有白海豚的帧数: 248 步骤4: 合并片段... 合并出 4 个片段 步骤5: 截取视频... 片段 0: 1234.56s -> 1246.89s 片段 1: 5678.12s -> 5690.33s ... 完成，片段保存在 output/clips

到output/clips目录查看生成的片段，用播放器确认每个片段确实有白海豚出现。如果某些片段里目标不明显，可以调整CONF_THRESHOLD和MIN_CLIP_FRAMES重新检测。

4.6 结果说明

这个脚本输出两类结果：

• output/frames/下是所有拆帧图片和对应的检测依据。
• output/clips/下是截取好的视频片段。

帧图片的价值在于可以配合人工标注工具做二次筛选，比如把置信度较低但视觉上确实是白海豚的帧挑出来，重新加入训练集迭代优化模型。视频片段则是最终交付成果，可以直接用于科研记录、档案整理或纪录片粗剪。

5. 常见问题与排查思路

5.1 CUDA 不可用导致推理速度极慢

问题现象：调用model.predict()时明显感觉速度很慢，日志显示使用 CPU 推理。

常见原因：PyTorch 安装的 CUDA 版本和本机显卡驱动不匹配，或者安装的是 CPU 版本 PyTorch。

排查步骤：

python -c "import torch; print(torch.cuda.is_available())"

输出False说明 CUDA 不可用。需要重新安装对应 CUDA 版本的 PyTorch。可以先查看驱动支持的 CUDA 版本：

nvidia-smi

右上角有 “CUDA Version” 信息，然后到 PyTorch 官网选择对应的安装命令。

5.2 检测效果差，经常漏检

问题现象：视频中白海豚非常明显，但模型没有检测到。

常见原因：

• 训练数据太少，模型没见过足够多角度和光照条件下的白海豚。
• 训练切片尺寸太小，白海豚在画面中占比过大导致边界框被截断。
• 视频分辨率高，模型对缩小后的目标不敏感。

解决思路：

• 增加训练数据，尽量覆盖清晨、傍晚、逆光、远距离、近距离等不同场景。
• 把imgsz从 640 提升到 960 或 1280，但要注意显存占用。
• 降低置信度阈值到 0.3 做初步筛选，再用人工方式确认。

5.3 片段断裂严重，同一次出现被切成多段

问题现象：白海豚明明连续出现在画面里好几分钟，结果被切成了好几个短片段。

常见原因：模型在中间某几帧漏检，导致连续帧之间超过MAX_GAP。

解决思路：

• 增大MAX_GAP，允许更多的帧数断档。
• 调低CONF_THRESHOLD，减少因为阈值过高导致的漏检。
• 对检测结果做插值修复，比如如果第 100 帧和第 110 帧有目标，而中间几帧没有，可以认为是连续片段。

5.4 视频处理太慢

问题现象：一段 1 小时的视频，跑了 20 分钟还没完成。

常见原因：

• 视频分辨率过高，比如 4K 视频单帧检测耗时明显。
• FRAME_STEP=1，每一帧都检测，没有利用时间连续性。

解决思路：

• 将视频先缩放再检测，比如把长边缩到 1280，检测速度会快很多。
• 增大FRAME_STEP，比如改成 2 或 3，间隔几帧检测一次，减少计算量。
• 使用批量推理，把多张帧图片放到一个 batch 里预测，而不是一次一张。

Ultralytics 支持批量列表输入：

results = model.predict(frame_batch, conf=0.5, verbose=False)

可以一次传入数十张图片，吞吐量会提升很多。

5.5 训练时显存不足

问题现象：训练开始时报CUDA out of memory。

常见原因：imgsz和batch设置过大，超过了显卡显存。

解决思路：

• 降低batch，从 8 改成 4 或 2。
• 降低imgsz，从 640 改成 512。
• 清理 GPU 上其他进程占用的显存，用nvidia-smi查看。

5.6 常见问题速查表

6. 最佳实践与工程建议

6.1 数据管理建议

数据质量直接决定模型效果。做野生动物目标检测时，数据往往是最消耗精力的一环。建议从这几个方面入手：

• 视频素材按日期、地点、拍摄设备归档，避免混合目录。
• 标注时尽量框住完整目标，不要只框背鳍或尾巴，除非你的目标本来就是局部特征。
• 每个场景至少标注 200 到 500 张有效图片，类别越多，每类图片数量也越多。
• 训练集和验证集不要有同一视频连续帧，否则验证集指标会虚高。建议按视频文件划分，而不是按图片划分。
• 标注图片保留原始分辨率，不要在标注前压得太小。

6.2 模型训练与选型建议

YOLO 系列有不同的尺寸，yolov8n、yolov8s、yolov8m、yolov8l、yolov8x速度依次变慢，精度通常依次提升。第一次千万不要直接上最大的模型，先用yolov8s跑通流程，再按需升级。

训练轮数不是越多越好。建议开启patience早停，否则验证集指标可能下降，产生过拟合。观察runs/.../results.png中的验证集指标曲线，如果训练集损失持续下降但验证集损失开始上升，说明过拟合，应停止训练。

6.3 后处理与片段截取建议

• 截取片段时不要只截“刚好有目标”的区间，建议前后各扩展 2 到 3 秒，让片段有上下文，便于人工查看。
• 输出片段生成后，抽样检查即可，不必所有帧都人工复核。
• 如果片段数量很多，可以生成一个 CSV 索引文件，记录片段名 | 开始时间 | 结束时间 | 包含目标帧数 | 最大置信度，方便后续检索。

import csv records = [] for idx, (start, end) in enumerate(clips): records.append([f"clip_{idx:03d}.mp4", start / fps, end / fps, end - start + 1]) with open("output/clips/summary.csv", "w", newline="", encoding="utf-8") as f: writer = csv.writer(f) writer.writerow(["文件名", "开始时间(秒)", "结束时间(秒)", "帧数"]) writer.writerows(records)

6.4 合规与安全注意事项

中华白海豚是国家一级保护动物，相关影像数据可能涉及保护栖息地和个体识别信息，在项目开发中应该注意：

• 未经许可不要使用敏感地理坐标做公开标注。
• 涉及保护动物影像时，不要使用可能干扰动物正常活动的无人机或拍摄设备。
• 模型和数据集的分享要遵循相关法律法规和科研伦理要求。
• 如果是科研用途，建议与相关保护研究机构合作，确保数据来源合法、使用合理。

6.5 工程化部署建议

视频检测脚本在开发环境跑通后，如果需要长期处理大量视频，建议考虑以下工程化改造：

• 用队列任务管理工具调度视频处理任务，比如 Celery 加 Redis，或者简单的 Shell 脚本批量调度。
• 把配置文件从脚本中抽离为 YAML，避免改参数就要改代码。
• 对处理结果写日志，包括视频路径、检测帧数、片段数、处理耗时，方便统计和排错。
• 如果视频量很大，优先用 GPU 服务器批量跑批处理，避免频繁模型加载。

7. 总结与学习路线

这篇文章围绕“判断一个视频里是否包含白海豚，并截取对应片段”这个需求，完整梳理了从环境准备、数据集标注、模型训练、视频拆帧、目标检测到片段合并的完整流程。核心收获有几个：

• 把视频问题拆成“拆帧 + 图像目标检测 + 时间片段合并”三个子问题，每一步都有明确的输入输出。
• YOLO 系列模型在视频目标检测场景下速度快、部署简单，配合预训练权重做迁移学习，即使数据量不大也能得到可用模型。
• 置信度阈值、最大断档帧数、最短片段长度这三个参数，是平衡漏检、误检和片段完整性的关键，需要在真实数据上反复调优。
• 工程上要重视数据目录规范、日志记录和结果索引文件，这能让后续模型迭代和视频排查省下大量时间。

如果你是第一次接触目标检测，建议按下面的顺序继续学习：

1. 先跑通一个公开数据集的目标检测流程，比如 COCO 上的 YOLO 推理，理解检测结果的数据结构。
2. 自己标注几百张图片，训练一个单类别检测模型，体会数据质量对结果的影响。
3. 将模型接入视频流，完成视频拆帧、检测、片段输出的完整闭环。
4. 再深入优化，比如模型剪枝量化、基于时序信息的跟踪和插值、边缘设备部署。

如果你已有目标检测基础，可以把重心放在视频后处理和工程化上，比如如何降低漏检、如何合并时序片段、如何批量处理大规模视频数据。这套方案里的代码和调优思路，可以直接复用到类似的野生动物监测场景。

最后给一个实用提示：第一次跑完整流程时，不要拿一整天的长视频做测试，先剪出 5 到 10 分钟包含白海豚的视频片段，跑通后再扩展到全量数据。这样能快速验证模型效果和参数设置，避免等几个小时才发现某个环节出了问题。如果这篇文章对你有帮助，可以收藏备用，后续基于 YOLO 的视频目标检测项目都能参照这套流程来实施。