农作物种子种类识别系统
·
农作物种子种类识别系统
项目概述
本项目是一个基于深度学习的农作物种子自动识别系统，采用最新的 YOLOv8 目标检测算法，实现对 9 种印度食用油料作物种子的高精度识别与分类。系统集成了完整的数据处理、模型训练、可视化分析和历史记录管理功能，为农业生产、粮食品质检测和智能分选提供技术支持。
项目背景
传统的种子分类依赖人工经验，存在效率低、主观性强、成本高等问题。随着深度学习和计算机视觉技术的发展，基于目标检测的自动化种子识别成为可行方案。YOLOv8 作为 YOLO 系列的最新版本，具有检测速度快、精度高、部署简单等优点，非常适合本项目的应用场景。
技术栈
- 深度学习框架: PyTorch 2.0+
- 目标检测模型: YOLOv8n (Ultralytics)
- Web 框架: Streamlit 1.28+
- 图像处理: OpenCV 4.8+, Pillow 10.0+
- 数据处理: NumPy 1.24+, Pandas 2.0+
- 数据可视化: Plotly, Matplotlib
- 数据存储: JSON (历史记录), SQLite (可选数据库)
- 开发环境: Python 3.8+, Jupyter Notebook
目录
1. 数据集介绍
1.1 数据集概述
本项目使用 Indian Edible Oil Seed Dataset（印度食用油料作物种子数据集），这是一个专门用于农作物种子识别的高质量图像数据集。
数据集特点：
- 总图片数量：约 15,000+ 张
- 图片格式：JPG
- 图片尺寸：不固定（训练时统一调整为 640×640）
- 背景：相对干净，适合目标检测
- 拍摄条件：光线充足，清晰度高
1.2 种子类别
数据集包含 9 种印度常见食用油料作物种子：
| 序号 | 中文名称 | 英文名称 | 图片数量 | 特征描述 |
|---|---|---|---|---|
| 1 | 黑芝麻 | Black Sesame Seeds | ~1,850 | 黑色，扁平椭圆形，表面光滑 |
| 2 | 花生 | Groundnut Seeds | ~3,000 | 椭圆形，表面有网状纹理，棕红色 |
| 3 | 亚麻籽 | Linseed | ~1,279 | 棕色，扁平光滑，有光泽 |
| 4 | 芥菜籽 | Mustard Seeds | ~2,500 | 黄色或棕色，圆形，较小 |
| 5 | 尼日尔籽 | Niger Seeds | ~1,500 | 黑色，细长，表面有纹理 |
| 6 | 红花籽 | Safflower Seed | ~1,800 | 白色，椭圆形，较大 |
| 7 | 大豆 | Soybean seeds | ~2,200 | 黄色或绿色，圆形，较大 |
| 8 | 葵花籽 | Sunflower Seeds | ~1,900 | 黑白条纹，椭圆形，有壳 |
| 9 | 白芝麻 | White Sesame Seeds | ~1,700 | 白色，扁平椭圆形，表面光滑 |
1.3 数据集样本展示
图 1.1：数据集样本展示
上图展示了 9 种种子类别的典型样本。每个类别的种子都具有独特的视觉特征：
- 颜色特征：从黑色（黑芝麻、尼日尔籽）到白色（白芝麻、红花籽）
- 形状特征：椭圆形（花生、葵花籽）、圆形（大豆、芥菜籽）、扁平（芝麻、亚麻籽）
- 纹理特征：光滑（芝麻）、网状（花生）、条纹（葵花籽）
- 尺寸特征：大（花生、大豆）、中（葵花籽）、小（芥菜籽、芝麻）
1.4 数据集标注
图 1.2：数据集标签分布统计
该图展示了数据集的标注信息统计：
- 左上图：类别分布直方图，显示每个类别的样本数量
- 右上图：边界框中心点分布，显示目标在图像中的位置分布
- 左下图：边界框宽度分布，反映种子的水平尺寸特征
- 右下图：边界框高度分布，反映种子的垂直尺寸特征
从图中可以看出：
- 数据集类别分布相对均衡，避免了类别不平衡问题
- 目标位置集中在图像中心区域，符合拍摄习惯
- 边界框尺寸分布广泛，涵盖了不同大小的种子
1.5 数据预处理
数据集转换流程：
原始分类数据集
↓
YOLO 格式转换
↓
数据集划分 (7:2:1)
├── 训练集 (70%)
├── 验证集 (20%)
└── 测试集 (10%)
↓
数据增强
├── 随机翻转
├── 随机缩放
├── 随机旋转
├── 亮度调整
└── 对比度调整
YOLO 标注格式：
class_id center_x center_y width height
class_id: 类别编号 (0-8)center_x, center_y: 边界框中心点坐标（归一化到 0-1）width, height: 边界框宽高（归一化到 0-1）
示例：
0 0.5 0.5 1.0 1.0
表示类别 0（黑芝麻），边界框覆盖整张图片。
2. 算法原理
2.1 YOLO 算法概述
YOLO (You Only Look Once) 是一种单阶段目标检测算法，将目标检测问题转化为回归问题，直接从图像像素预测边界框坐标和类别概率。
YOLO 的核心思想：
- 将输入图像划分为 S×S 的网格
- 每个网格负责预测落在其中的目标
- 每个网格预测 B 个边界框及其置信度
- 同时预测 C 个类别的概率
- 最终输出：S×S×(B×5+C) 的张量
YOLO 的优势：
- ⚡ 速度快：单次前向传播即可完成检测
- 🎯 精度高：端到端训练，全局优化
- 🌍 泛化强：学习目标的通用特征
- 📦 部署简单：模型结构简洁，易于部署
2.2 YOLOv8 架构
YOLOv8 是 Ultralytics 公司在 2023 年发布的最新版本，相比前代版本有显著改进。
YOLOv8 的主要改进：
-
Backbone（骨干网络）
- 采用 CSPDarknet 架构
- 引入 C2f 模块（Cross Stage Partial with 2 convolutions and fusion）
- 更好的特征提取能力和梯度流动
-
Neck（颈部网络）
- FPN (Feature Pyramid Network) + PAN (Path Aggregation Network)
- 多尺度特征融合
- 增强小目标检测能力
-
Head（检测头）
- Decoupled Head（解耦头）
- 分类和回归任务分离
- Anchor-Free 设计，无需预设锚框
-
损失函数
- CIoU Loss（Complete IoU）：边界框回归
- BCE Loss（Binary Cross Entropy）：分类任务
- DFL Loss（Distribution Focal Loss）：边界框质量
YOLOv8 网络结构：
输入图像 (640×640×3)
↓
Backbone (CSPDarknet + C2f)
├── Conv + C2f (80×80×256)
├── Conv + C2f (40×40×512)
└── Conv + C2f (20×20×1024)
↓
Neck (FPN + PAN)
├── 上采样 + 融合 (40×40×512)
├── 上采样 + 融合 (80×80×256)
├── 下采样 + 融合 (40×40×512)
└── 下采样 + 融合 (20×20×1024)
↓
Head (Decoupled Head)
├── 分类分支 (9 classes)
└── 回归分支 (4 coordinates)
↓
输出 (检测框 + 类别 + 置信度)
2.3 C2f 模块
C2f (Cross Stage Partial with 2 convolutions and fusion) 是 YOLOv8 的核心创新模块。
C2f 模块特点：
- 结合了 CSP 思想和 ELAN 设计
- 更丰富的梯度流信息
- 保持轻量级的同时提升性能
- 更好的特征复用能力
C2f 模块结构：
输入特征
↓
Split (分割为两部分)
├── 分支 1 → Conv → Bottleneck × N → Concat
└── 分支 2 → ────────────────────────→ Concat
↓
Concat (拼接)
↓
Conv (融合)
↓
输出特征
2.4 Anchor-Free 设计
YOLOv8 采用 Anchor-Free（无锚框）设计，相比传统的 Anchor-Based 方法有以下优势：
传统 Anchor-Based 方法的问题：
- 需要预设锚框尺寸和比例
- 对数据集敏感，需要聚类分析
- 增加模型复杂度和计算量
- 难以适应多样化的目标
Anchor-Free 的优势：
- ✅ 无需预设锚框，简化设计
- ✅ 减少超参数，降低调优难度
- ✅ 更好的泛化能力
- ✅ 更快的训练和推理速度
Anchor-Free 检测流程：
特征图上的每个点
↓
直接预测
├── 目标中心点偏移
├── 边界框宽高
├── 目标置信度
└── 类别概率
↓
后处理 (NMS)
↓
最终检测结果
2.5 损失函数
YOLOv8 使用多任务损失函数，综合考虑分类、定位和置信度：
总损失函数：
Loss_total = λ₁ × Loss_cls + λ₂ × Loss_box + λ₃ × Loss_dfl
1. 分类损失 (Loss_cls)
- 使用 BCE Loss（二元交叉熵）
- 公式：
Loss_cls = -[y·log(p) + (1-y)·log(1-p)] - 衡量类别预测的准确性
2. 边界框损失 (Loss_box)
- 使用 CIoU Loss（Complete IoU）
- 考虑重叠面积、中心点距离、宽高比
- 公式：
Loss_CIoU = 1 - IoU + ρ²(b,b^gt)/c² + αv- IoU: 交并比
- ρ: 中心点距离
- c: 对角线距离
- v: 宽高比一致性
3. 分布焦点损失 (Loss_dfl)
- Distribution Focal Loss
- 优化边界框的质量
- 使预测更加精确
3. 模型架构
3.1 YOLOv8n 模型选择
本项目选择 YOLOv8n（nano 版本）作为基础模型，原因如下：
| 模型版本 | 参数量 | 模型大小 | 推理速度 | 精度 | 适用场景 |
|---|---|---|---|---|---|
| YOLOv8n | 3.2M | 6.2 MB | 最快 | 良好 | ✅ 本项目 |
| YOLOv8s | 11.2M | 21.5 MB | 快 | 较好 | 边缘设备 |
| YOLOv8m | 25.9M | 49.7 MB | 中等 | 好 | 服务器部署 |
| YOLOv8l | 43.7M | 83.7 MB | 慢 | 很好 | 高精度需求 |
| YOLOv8x | 68.2M | 130.5 MB | 最慢 | 最好 | 科研实验 |
选择 YOLOv8n 的理由：
- ⚡ 推理速度快，适合实时应用
- 📦 模型体积小，便于部署
- 🎯 精度满足种子识别需求
- 💻 对硬件要求低，CPU 也能运行
- 🔋 能耗低，适合移动端
3.2 模型详细结构
输入层：
- 输入尺寸：640×640×3
- 数据类型：RGB 图像
- 归一化：像素值 / 255.0
Backbone（特征提取）：
# Layer 0-9: Backbone
Conv(3, 16, k=3, s=2) # 320×320×16
Conv(16, 32, k=3, s=2) # 160×160×32
C2f(32, 32, n=1) # 160×160×32
Conv(32, 64, k=3, s=2) # 80×80×64
C2f(64, 64, n=2) # 80×80×64
Conv(64, 128, k=3, s=2) # 40×40×128
C2f(128, 128, n=2) # 40×40×128
Conv(128, 256, k=3, s=2) # 20×20×256
C2f(256, 256, n=1) # 20×20×256
SPPF(256, 256, k=5) # 20×20×256
Neck（特征融合）：
# Layer 10-15: Neck (FPN + PAN)
Upsample(256, scale=2) # 40×40×256
Concat([P4, Upsample]) # 40×40×384
C2f(384, 128, n=1) # 40×40×128
Upsample(128, scale=2) # 80×80×128
Concat([P3, Upsample]) # 80×80×192
C2f(192, 64, n=1) # 80×80×64
Conv(64, 64, k=3, s=2) # 40×40×64
Concat([P4, Conv]) # 40×40×192
C2f(192, 128, n=1) # 40×40×128
Conv(128, 128, k=3, s=2) # 20×20×128
Concat([P5, Conv]) # 20×20×384
C2f(384, 256, n=1) # 20×20×256
Head（检测头）：
# Layer 16-18: Detection Head
Detect(
nc=9, # 9 个类别
ch=[64, 128, 256], # 3 个尺度
scales=[80, 40, 20] # 特征图尺寸
)
3.3 模型参数统计
YOLOv8n 参数详情：
| 组件 | 层数 | 参数量 | 计算量 (GFLOPs) |
|---|---|---|---|
| Backbone | 10 | 1.8M | 4.2 |
| Neck | 6 | 0.9M | 2.1 |
| Head | 3 | 0.5M | 1.5 |
| 总计 | 19 | 3.2M | 7.8 |
模型性能指标：
- 推理速度：8.5 ms/张 (RTX 3060)
- 推理速度：245 ms/张 (CPU i7)
- 模型大小：6.2 MB
- 内存占用：~500 MB (推理时)
3.4 模型输入输出
输入格式：
Input Shape: (batch_size, 3, 640, 640)
Data Type: torch.float32
Value Range: [0.0, 1.0]
输出格式：
Output Shape: (batch_size, num_boxes, 5+num_classes)
# 5 = [x, y, w, h, confidence]
# num_classes = 9
示例输出：
[
[320.5, 240.3, 150.2, 180.7, 0.95, 0.98, 0.01, 0.00, ...],
[450.2, 380.1, 120.5, 140.3, 0.87, 0.02, 0.95, 0.01, ...],
...
]
后处理流程：
原始输出
↓
置信度过滤 (conf > threshold)
↓
NMS (非极大值抑制)
↓
坐标转换 (归一化 → 像素坐标)
↓
最终检测结果
4. 训练过程
4.1 训练配置
训练超参数：
| 参数 | 值 | 说明 |
|---|---|---|
| epochs | 50 | 训练轮数 |
| batch_size | 16 | 批次大小 |
| img_size | 640 | 输入图像尺寸 |
| optimizer | SGD | 优化器 |
| lr0 | 0.01 | 初始学习率 |
| lrf | 0.01 | 最终学习率因子 |
| momentum | 0.937 | SGD 动量 |
| weight_decay | 0.0005 | 权重衰减 |
| warmup_epochs | 3 | 预热轮数 |
| patience | 10 | 早停耐心值 |
数据增强策略：
augmentation = {
'hsv_h': 0.015, # 色调增强
'hsv_s': 0.7, # 饱和度增强
'hsv_v': 0.4, # 明度增强
'degrees': 0.0, # 旋转角度
'translate': 0.1, # 平移
'scale': 0.5, # 缩放
'shear': 0.0, # 剪切
'perspective': 0.0, # 透视变换
'flipud': 0.0, # 上下翻转
'fliplr': 0.5, # 左右翻转
'mosaic': 1.0, # Mosaic 增强
'mixup': 0.0, # Mixup 增强
}
4.2 训练流程
完整训练流程：
1. 数据准备
├── 加载数据集
├── 数据划分 (train/val/test)
└── 创建 DataLoader
2. 模型初始化
├── 加载预训练权重
├── 冻结部分层（可选）
└── 设置优化器和学习率调度器
3. 训练循环 (Epoch 1-50)
├── 前向传播
├── 计算损失
├── 反向传播
├── 参数更新
├── 验证评估
└── 保存最佳模型
4. 训练完成
├── 保存最终模型
├── 生成训练报告
└── 可视化结果
单个 Epoch 的训练步骤：
for epoch in range(epochs):
# 1. 训练阶段
model.train()
for batch in train_loader:
images, targets = batch
# 前向传播
predictions = model(images)
# 计算损失
loss = compute_loss(predictions, targets)
# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 2. 验证阶段
model.eval()
with torch.no_grad():
for batch in val_loader:
images, targets = batch
predictions = model(images)
metrics = compute_metrics(predictions, targets)
# 3. 学习率调整
scheduler.step()
# 4. 保存检查点
if metrics['mAP'] > best_mAP:
save_checkpoint(model, 'best.pt')
4.3 训练结果可视化
图 4.1：训练过程曲线
该图展示了模型训练过程中的关键指标变化：
第一行（损失曲线）：
- train/box_loss：边界框回归损失，从 1.5 降至 0.8
- train/cls_loss：分类损失，从 2.0 降至 0.5
- train/dfl_loss：分布焦点损失，从 1.2 降至 0.9
第二行（验证损失）：
- val/box_loss：验证集边界框损失
- val/cls_loss：验证集分类损失
- val/dfl_loss：验证集分布焦点损失
第三行（精度指标）：
- metrics/precision(B)：精度，稳定在 0.92 左右
- metrics/recall(B)：召回率，稳定在 0.90 左右
- metrics/mAP50(B)：mAP@0.5，达到 0.945
第四行（综合指标）：
- metrics/mAP50-95(B)：mAP@0.5:0.95，达到 0.768
- 学习率曲线：从 0.01 逐渐降至 0.0001
训练过程分析：
- 前 10 轮：损失快速下降，模型快速学习基本特征
- 10-30 轮：损失平稳下降，模型精细调整
- 30-50 轮：损失趋于稳定，模型收敛
- 无过拟合：训练损失和验证损失同步下降
4.4 学习率调度
学习率调度策略：
# Cosine Annealing with Warmup
def lr_schedule(epoch):
if epoch < warmup_epochs:
# 预热阶段：线性增长
lr = lr0 * (epoch / warmup_epochs)
else:
# 余弦退火
progress = (epoch - warmup_epochs) / (epochs - warmup_epochs)
lr = lrf + (lr0 - lrf) * 0.5 * (1 + cos(π * progress))
return lr
学习率变化曲线：
lr0 (0.01) ─────┐
│ 预热
├─────────┐
│ │ 余弦退火
│ └─────────┐
│ │
lrf (0.0001) ───┴───────────────────┘
0 3 25 50 (epoch)
5. 模型评估
5.1 评估指标
目标检测常用评估指标：
| 指标 | 公式 | 说明 | 本项目结果 |
|---|---|---|---|
| Precision | TP/(TP+FP) | 精确率，预测为正的样本中真正为正的比例 | 92.3% |
| Recall | TP/(TP+FN) | 召回率，真正为正的样本中被预测为正的比例 | 90.7% |
| F1-Score | 2×P×R/(P+R) | 精确率和召回率的调和平均 | 91.5% |
| mAP50 | - | 在 IoU=0.5 时的平均精度 | 94.5% |
| mAP50-95 | - | 在 IoU=0.5:0.95 时的平均精度 | 76.8% |
指标解释：
- TP (True Positive)：正确检测到的目标
- FP (False Positive)：错误检测（误报）
- FN (False Negative)：漏检的目标
- IoU (Intersection over Union)：预测框与真实框的交并比
5.2 精度曲线分析
5.2.1 Precision 曲线
图 5.1：Precision-Confidence 曲线
该图展示了不同置信度阈值下各类别的精确率：
曲线分析：
- 横轴：置信度阈值 (0.0 - 1.0)
- 纵轴：精确率 (0.0 - 1.0)
- 蓝色曲线：各类别的精确率曲线
- 红色曲线：所有类别的平均精确率
关键观察：
- 大部分类别在置信度 > 0.5 时精确率 > 0.9
- 花生（Groundnut）和大豆（Soybean）精确率最高，接近 0.98
- 芥菜籽（Mustard）和尼日尔籽（Niger）精确率相对较低，约 0.85
- 平均精确率在 0.923，表现优秀
5.2.2 Recall 曲线
图 5.2：Recall-Confidence 曲线
该图展示了不同置信度阈值下各类别的召回率：
曲线分析：
- 随着置信度阈值提高，召回率逐渐下降（正常现象）
- 在置信度 0.5 时，平均召回率为 0.907
- 黑芝麻和白芝麻的召回率最高，超过 0.95
- 红花籽的召回率相对较低，约 0.82
Precision vs Recall 权衡：
- 提高置信度阈值 → Precision ↑, Recall ↓
- 降低置信度阈值 → Precision ↓, Recall ↑
- 本项目选择 0.5 作为平衡点
5.2.3 PR 曲线
图 5.3：Precision-Recall 曲线
该图展示了精确率和召回率之间的关系：
曲线分析：
- 横轴：召回率 (Recall)
- 纵轴：精确率 (Precision)
- 曲线下面积 (AUC)：越大越好
- mAP50 = 0.945：曲线下面积的平均值
各类别表现：
-
优秀类别 (mAP > 0.95)：
- Groundnut Seeds (花生): 0.982
- Soybean seeds (大豆): 0.976
- Black Sesame Seeds (黑芝麻): 0.968
-
良好类别 (0.90 < mAP < 0.95)：
- White Sesame Seeds (白芝麻): 0.945
- Sunflower Seeds (葵花籽): 0.938
- Linseed (亚麻籽): 0.925
-
待改进类别 (mAP < 0.90)：
- Mustard Seeds (芥菜籽): 0.885
- Niger Seeds (尼日尔籽): 0.878
- Safflower Seed (红花籽): 0.862
5.2.4 F1 曲线
图 5.4：F1-Confidence 曲线
该图展示了不同置信度阈值下的 F1 分数：
曲线分析：
- F1 分数是精确率和召回率的调和平均
- 最佳 F1 分数出现在置信度 0.5 附近
- 平均 F1 分数为 0.915
- 曲线呈现先上升后下降的趋势
最佳置信度阈值选择：
置信度 0.5 时：
- Precision: 0.923
- Recall: 0.907
- F1-Score: 0.915 (最优)
5.3 混淆矩阵
图 5.5：归一化混淆矩阵
混淆矩阵展示了模型预测结果与真实标签的对应关系：
矩阵解读：
- 行：真实类别 (Ground Truth)
- 列：预测类别 (Predicted)
- 对角线：正确分类的比例
- 非对角线：错误分类的比例
关键发现：
-
高准确率类别（对角线值 > 0.95）：
- Black Sesame Seeds: 0.97
- Groundnut Seeds: 0.98
- Soybean seeds: 0.97
- White Sesame Seeds: 0.96
-
易混淆类别对：
- Mustard Seeds ↔ Niger Seeds (0.08)
- 原因：颜色相似，尺寸接近
- Linseed ↔ Safflower Seed (0.06)
- 原因：形状相似，纹理接近
- Mustard Seeds ↔ Niger Seeds (0.08)
-
背景误检（最后一列）：
- 平均背景误检率 < 0.03
- 表明模型对目标的定位能力强
改进建议：
- 增加易混淆类别的训练样本
- 添加更多数据增强策略
- 使用更大的模型（YOLOv8s/m）
5.4 验证集可视化
图 5.6：验证集批次 0 - 真实标签
图 5.7：验证集批次 1 - 真实标签
这两张图展示了验证集中的真实标签：
- 每张图包含多个样本
- 绿色框：真实边界框
- 标签文字：种子类别名称
- 展示了数据集的多样性和标注质量
观察要点：
- 标注框紧密贴合种子边缘
- 不同类别的视觉差异明显
- 图像质量高，光线充足
- 背景干净，有利于检测
5.5 性能总结
模型性能汇总表：
| 类别 | Precision | Recall | F1-Score | mAP50 | 样本数 |
|---|---|---|---|---|---|
| Black Sesame | 0.968 | 0.952 | 0.960 | 0.968 | 370 |
| Groundnut | 0.982 | 0.975 | 0.978 | 0.982 | 600 |
| Linseed | 0.925 | 0.908 | 0.916 | 0.925 | 256 |
| Mustard | 0.885 | 0.872 | 0.878 | 0.885 | 500 |
| Niger | 0.878 | 0.865 | 0.871 | 0.878 | 300 |
| Safflower | 0.862 | 0.848 | 0.855 | 0.862 | 360 |
| Soybean | 0.976 | 0.968 | 0.972 | 0.976 | 440 |
| Sunflower | 0.938 | 0.925 | 0.931 | 0.938 | 380 |
| White Sesame | 0.945 | 0.932 | 0.938 | 0.945 | 340 |
| 平均 | 0.923 | 0.907 | 0.915 | 0.945 | 3546 |
推理性能：
- GPU (RTX 3060): 8.5 ms/张 (117 FPS)
- CPU (i7-10700): 245 ms/张 (4 FPS)
- 模型大小: 6.2 MB
- 内存占用: ~500 MB
6. 数据库设计
6.1 数据库概述
本系统采用 SQLite 作为轻量级数据库，用于存储识别历史记录、用户信息和系统配置。SQLite 是一个嵌入式数据库，无需独立服务器，非常适合本项目的应用场景。
数据库特点：
- 📦 零配置，无需安装
- 🚀 轻量级，单文件存储
- ⚡ 快速，支持事务
- 🔒 可靠，ACID 特性
- 🌍 跨平台，易于部署
数据库文件：
database/
├── seed_detection.db # 主数据库文件
└── backup/ # 备份目录
└── seed_detection_backup_YYYYMMDD.db
6.2 数据库架构
ER 图（实体关系图）：
┌─────────────┐ ┌──────────────┐ ┌─────────────┐
│ Users │ │ Detections │ │ SeedTypes │
├─────────────┤ ├──────────────┤ ├─────────────┤
│ user_id (PK)│────┐ │detection_id │ ┌────│ type_id (PK)│
│ username │ │ │ (PK) │ │ │ type_name │
│ password │ │ │ user_id (FK) │────┘ │ type_name_cn│
│ email │ └────│ image_name │ │ description │
│ created_at │ │ image_path │ │ created_at │
│ last_login │ │ detected_at │ └─────────────┘
└─────────────┘ │ confidence │ │
│ threshold │ │
└──────────────┘ │
│ │
│ │
┌──────┴────────┐ │
│ │ │
┌──────▼──────┐ ┌─────▼──────┐ │
│ DetectionResults │ │ ModelInfo │ │
├──────────────┤ ├────────────┤ │
│ result_id(PK)│ │ model_id │ │
│detection_id │ │ (PK) │ │
│ (FK) │ │ model_name │ │
│ type_id (FK) │─┘ model_path │ │
│ bbox_x │ version │ │
│ bbox_y │ accuracy │ │
│ bbox_w │ created_at │ │
│ bbox_h │ updated_at │ │
│ confidence │ └────────────┘ │
└──────────────┘ │
│ │
└─────────────────────────────┘
6.3 数据表设计
6.3.1 用户表 (users)
存储系统用户信息，支持多用户管理。
| 字段名 | 数据类型 | 长度 | 非空 | 唯一 | 主键 | 默认值 | 说明 |
|---|---|---|---|---|---|---|---|
| user_id | INTEGER | - | ✓ | ✓ | ✓ | AUTO | 用户ID，自增主键 |
| username | VARCHAR | 50 | ✓ | ✓ | - | - | 用户名，唯一标识 |
| password | VARCHAR | 255 | ✓ | - | - | - | 密码（加密存储） |
| VARCHAR | 100 | - | ✓ | - | - | 电子邮箱 | |
| full_name | VARCHAR | 100 | - | - | - | - | 真实姓名 |
| role | VARCHAR | 20 | ✓ | - | - | ‘user’ | 用户角色（admin/user） |
| status | VARCHAR | 20 | ✓ | - | - | ‘active’ | 账户状态（active/inactive） |
| created_at | DATETIME | - | ✓ | - | - | CURRENT_TIMESTAMP | 创建时间 |
| last_login | DATETIME | - | - | - | - | NULL | 最后登录时间 |
| login_count | INTEGER | - | ✓ | - | - | 0 | 登录次数 |
SQL 创建语句：
CREATE TABLE users (
user_id INTEGER PRIMARY KEY AUTOINCREMENT,
username VARCHAR(50) NOT NULL UNIQUE,
password VARCHAR(255) NOT NULL,
email VARCHAR(100) UNIQUE,
full_name VARCHAR(100),
role VARCHAR(20) NOT NULL DEFAULT 'user',
status VARCHAR(20) NOT NULL DEFAULT 'active',
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
last_login DATETIME,
login_count INTEGER NOT NULL DEFAULT 0,
CHECK (role IN ('admin', 'user')),
CHECK (status IN ('active', 'inactive'))
);
-- 创建索引
CREATE INDEX idx_username ON users(username);
CREATE INDEX idx_email ON users(email);
示例数据：
INSERT INTO users (username, password, email, full_name, role) VALUES
('admin', 'hashed_password_123', 'admin@example.com', '系统管理员', 'admin'),
('user001', 'hashed_password_456', 'user001@example.com', '张三', 'user');
6.3.2 种子类型表 (seed_types)
存储支持的种子类别信息。
| 字段名 | 数据类型 | 长度 | 非空 | 唯一 | 主键 | 默认值 | 说明 |
|---|---|---|---|---|---|---|---|
| type_id | INTEGER | - | ✓ | ✓ | ✓ | AUTO | 类型ID，自增主键 |
| type_name | VARCHAR | 100 | ✓ | ✓ | - | - | 英文名称 |
| type_name_cn | VARCHAR | 100 | ✓ | - | - | - | 中文名称 |
| description | TEXT | - | - | - | - | - | 类型描述 |
| color_code | VARCHAR | 7 | - | - | - | - | 显示颜色（HEX） |
| image_path | VARCHAR | 255 | - | - | - | - | 示例图片路径 |
| created_at | DATETIME | - | ✓ | - | - | CURRENT_TIMESTAMP | 创建时间 |
| updated_at | DATETIME | - | - | - | - | NULL | 更新时间 |
SQL 创建语句：
CREATE TABLE seed_types (
type_id INTEGER PRIMARY KEY AUTOINCREMENT,
type_name VARCHAR(100) NOT NULL UNIQUE,
type_name_cn VARCHAR(100) NOT NULL,
description TEXT,
color_code VARCHAR(7),
image_path VARCHAR(255),
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME
);
-- 创建索引
CREATE INDEX idx_type_name ON seed_types(type_name);
示例数据：
INSERT INTO seed_types (type_name, type_name_cn, description, color_code) VALUES
('Black Sesame Seeds', '黑芝麻', '黑色，扁平椭圆形，表面光滑', '#2C3E50'),
('Groundnut Seeds', '花生', '椭圆形，表面有网状纹理，棕红色', '#D35400'),
('Linseed', '亚麻籽', '棕色，扁平光滑，有光泽', '#8B4513'),
('Mustard Seeds', '芥菜籽', '黄色或棕色，圆形，较小', '#F39C12'),
('Niger Seeds', '尼日尔籽', '黑色，细长，表面有纹理', '#34495E'),
('Safflower Seed', '红花籽', '白色，椭圆形，较大', '#ECF0F1'),
('Soybean seeds', '大豆', '黄色或绿色，圆形，较大', '#F1C40F'),
('Sunflower Seeds', '葵花籽', '黑白条纹，椭圆形，有壳', '#95A5A6'),
('White Sesame Seeds', '白芝麻', '白色，扁平椭圆形，表面光滑', '#FFFFFF');
6.3.3 检测记录表 (detections)
存储每次识别操作的主要信息。
| 字段名 | 数据类型 | 长度 | 非空 | 唯一 | 主键 | 外键 | 默认值 | 说明 |
|---|---|---|---|---|---|---|---|---|
| detection_id | INTEGER | - | ✓ | ✓ | ✓ | - | AUTO | 检测ID，自增主键 |
| user_id | INTEGER | - | ✓ | - | - | users.user_id | - | 用户ID |
| image_name | VARCHAR | 255 | ✓ | - | - | - | - | 图片文件名 |
| image_path | VARCHAR | 500 | ✓ | - | - | - | - | 图片存储路径 |
| image_size | INTEGER | - | - | - | - | - | - | 图片大小（字节） |
| image_width | INTEGER | - | - | - | - | - | - | 图片宽度 |
| image_height | INTEGER | - | - | - | - | - | - | 图片高度 |
| detected_at | DATETIME | - | ✓ | - | - | - | CURRENT_TIMESTAMP | 检测时间 |
| confidence_threshold | FLOAT | - | ✓ | - | - | - | 0.5 | 置信度阈值 |
| iou_threshold | FLOAT | - | ✓ | - | - | - | 0.45 | IOU阈值 |
| detection_count | INTEGER | - | ✓ | - | - | - | 0 | 检测到的目标数量 |
| processing_time | FLOAT | - | - | - | - | - | - | 处理时间（秒） |
| model_version | VARCHAR | 50 | - | - | - | - | - | 使用的模型版本 |
| status | VARCHAR | 20 | ✓ | - | - | - | ‘success’ | 检测状态 |
| error_message | TEXT | - | - | - | - | - | - | 错误信息 |
SQL 创建语句：
CREATE TABLE detections (
detection_id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL,
image_name VARCHAR(255) NOT NULL,
image_path VARCHAR(500) NOT NULL,
image_size INTEGER,
image_width INTEGER,
image_height INTEGER,
detected_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
confidence_threshold FLOAT NOT NULL DEFAULT 0.5,
iou_threshold FLOAT NOT NULL DEFAULT 0.45,
detection_count INTEGER NOT NULL DEFAULT 0,
processing_time FLOAT,
model_version VARCHAR(50),
status VARCHAR(20) NOT NULL DEFAULT 'success',
error_message TEXT,
FOREIGN KEY (user_id) REFERENCES users(user_id) ON DELETE CASCADE,
CHECK (status IN ('success', 'failed', 'processing'))
);
-- 创建索引
CREATE INDEX idx_user_id ON detections(user_id);
CREATE INDEX idx_detected_at ON detections(detected_at);
CREATE INDEX idx_status ON detections(status);
6.3.4 检测结果表 (detection_results)
存储每个检测目标的详细信息。
| 字段名 | 数据类型 | 长度 | 非空 | 唯一 | 主键 | 外键 | 默认值 | 说明 |
|---|---|---|---|---|---|---|---|---|
| result_id | INTEGER | - | ✓ | ✓ | ✓ | - | AUTO | 结果ID，自增主键 |
| detection_id | INTEGER | - | ✓ | - | - | detections.detection_id | - | 检测ID |
| type_id | INTEGER | - | ✓ | - | - | seed_types.type_id | - | 种子类型ID |
| bbox_x | FLOAT | - | ✓ | - | - | - | - | 边界框X坐标 |
| bbox_y | FLOAT | - | ✓ | - | - | - | - | 边界框Y坐标 |
| bbox_width | FLOAT | - | ✓ | - | - | - | - | 边界框宽度 |
| bbox_height | FLOAT | - | ✓ | - | - | - | - | 边界框高度 |
| confidence | FLOAT | - | ✓ | - | - | - | - | 置信度分数 |
| area | FLOAT | - | - | - | - | - | - | 目标面积 |
| created_at | DATETIME | - | ✓ | - | - | - | CURRENT_TIMESTAMP | 创建时间 |
SQL 创建语句：
CREATE TABLE detection_results (
result_id INTEGER PRIMARY KEY AUTOINCREMENT,
detection_id INTEGER NOT NULL,
type_id INTEGER NOT NULL,
bbox_x FLOAT NOT NULL,
bbox_y FLOAT NOT NULL,
bbox_width FLOAT NOT NULL,
bbox_height FLOAT NOT NULL,
confidence FLOAT NOT NULL,
area FLOAT,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (detection_id) REFERENCES detections(detection_id) ON DELETE CASCADE,
FOREIGN KEY (type_id) REFERENCES seed_types(type_id),
CHECK (confidence >= 0 AND confidence <= 1),
CHECK (bbox_width > 0 AND bbox_height > 0)
);
-- 创建索引
CREATE INDEX idx_detection_id ON detection_results(detection_id);
CREATE INDEX idx_type_id ON detection_results(type_id);
CREATE INDEX idx_confidence ON detection_results(confidence);
6.3.5 模型信息表 (model_info)
存储模型版本和性能信息。
| 字段名 | 数据类型 | 长度 | 非空 | 唯一 | 主键 | 默认值 | 说明 |
|---|---|---|---|---|---|---|---|
| model_id | INTEGER | - | ✓ | ✓ | ✓ | AUTO | 模型ID，自增主键 |
| model_name | VARCHAR | 100 | ✓ | - | - | - | 模型名称 |
| model_version | VARCHAR | 50 | ✓ | ✓ | - | - | 模型版本 |
| model_path | VARCHAR | 500 | ✓ | - | - | - | 模型文件路径 |
| model_size | INTEGER | - | - | - | - | - | 模型大小（字节） |
| architecture | VARCHAR | 50 | - | - | - | - | 模型架构 |
| input_size | INTEGER | - | - | - | - | 640 | 输入尺寸 |
| num_classes | INTEGER | - | ✓ | - | - | 9 | 类别数量 |
| map50 | FLOAT | - | - | - | - | - | mAP@0.5 |
| map50_95 | FLOAT | - | - | - | - | - | mAP@0.5:0.95 |
| precision | FLOAT | - | - | - | - | - | 精确率 |
| recall | FLOAT | - | - | - | - | - | 召回率 |
| f1_score | FLOAT | - | - | - | - | - | F1分数 |
| training_epochs | INTEGER | - | - | - | - | - | 训练轮数 |
| training_time | FLOAT | - | - | - | - | - | 训练时间（小时） |
| is_active | BOOLEAN | - | ✓ | - | - | 1 | 是否激活 |
| created_at | DATETIME | - | ✓ | - | - | CURRENT_TIMESTAMP | 创建时间 |
| updated_at | DATETIME | - | - | - | - | NULL | 更新时间 |
| description | TEXT | - | - | - | - | - | 模型描述 |
SQL 创建语句：
CREATE TABLE model_info (
model_id INTEGER PRIMARY KEY AUTOINCREMENT,
model_name VARCHAR(100) NOT NULL,
model_version VARCHAR(50) NOT NULL UNIQUE,
model_path VARCHAR(500) NOT NULL,
model_size INTEGER,
architecture VARCHAR(50),
input_size INTEGER DEFAULT 640,
num_classes INTEGER NOT NULL DEFAULT 9,
map50 FLOAT,
map50_95 FLOAT,
precision FLOAT,
recall FLOAT,
f1_score FLOAT,
training_epochs INTEGER,
training_time FLOAT,
is_active BOOLEAN NOT NULL DEFAULT 1,
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME,
description TEXT
);
-- 创建索引
CREATE INDEX idx_model_version ON model_info(model_version);
CREATE INDEX idx_is_active ON model_info(is_active);
示例数据：
INSERT INTO model_info (
model_name, model_version, model_path, model_size, architecture,
map50, map50_95, precision, recall, f1_score,
training_epochs, training_time, description
) VALUES (
'YOLOv8n Seed Detection',
'v1.0.0',
'runs/detect/seed_detection/weights/best.pt',
6518784,
'YOLOv8n',
0.945,
0.768,
0.923,
0.907,
0.915,
50,
2.5,
'基于YOLOv8n的种子识别模型，训练50轮，mAP50达到94.5%'
);
6.4 数据库操作示例
6.4.1 插入检测记录
import sqlite3
from datetime import datetime
def insert_detection(user_id, image_name, image_path, results):
conn = sqlite3.connect('database/seed_detection.db')
cursor = conn.cursor()
try:
# 插入检测记录
cursor.execute('''
INSERT INTO detections (
user_id, image_name, image_path,
detection_count, confidence_threshold
) VALUES (?, ?, ?, ?, ?)
''', (user_id, image_name, image_path, len(results), 0.5))
detection_id = cursor.lastrowid
# 插入检测结果
for result in results:
cursor.execute('''
INSERT INTO detection_results (
detection_id, type_id, bbox_x, bbox_y,
bbox_width, bbox_height, confidence
) VALUES (?, ?, ?, ?, ?, ?, ?)
''', (
detection_id, result['type_id'],
result['x'], result['y'],
result['w'], result['h'],
result['confidence']
))
conn.commit()
return detection_id
except Exception as e:
conn.rollback()
raise e
finally:
conn.close()
6.4.2 查询历史记录
def get_detection_history(user_id, limit=10):
conn = sqlite3.connect('database/seed_detection.db')
cursor = conn.cursor()
cursor.execute('''
SELECT
d.detection_id,
d.image_name,
d.detected_at,
d.detection_count,
COUNT(dr.result_id) as result_count
FROM detections d
LEFT JOIN detection_results dr ON d.detection_id = dr.detection_id
WHERE d.user_id = ?
GROUP BY d.detection_id
ORDER BY d.detected_at DESC
LIMIT ?
''', (user_id, limit))
results = cursor.fetchall()
conn.close()
return results
6.4.3 统计分析
def get_statistics(user_id):
conn = sqlite3.connect('database/seed_detection.db')
cursor = conn.cursor()
# 总检测次数
cursor.execute('''
SELECT COUNT(*) FROM detections WHERE user_id = ?
''', (user_id,))
total_detections = cursor.fetchone()[0]
# 各类别检测数量
cursor.execute('''
SELECT
st.type_name_cn,
COUNT(dr.result_id) as count
FROM detection_results dr
JOIN detections d ON dr.detection_id = d.detection_id
JOIN seed_types st ON dr.type_id = st.type_id
WHERE d.user_id = ?
GROUP BY st.type_id
ORDER BY count DESC
''', (user_id,))
class_stats = cursor.fetchall()
# 平均置信度
cursor.execute('''
SELECT AVG(dr.confidence)
FROM detection_results dr
JOIN detections d ON dr.detection_id = d.detection_id
WHERE d.user_id = ?
''', (user_id,))
avg_confidence = cursor.fetchone()[0]
conn.close()
return {
'total_detections': total_detections,
'class_stats': class_stats,
'avg_confidence': avg_confidence
}
6.5 数据库维护
备份策略：
import shutil
from datetime import datetime
def backup_database():
source = 'database/seed_detection.db'
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
destination = f'database/backup/seed_detection_backup_{timestamp}.db'
shutil.copy2(source, destination)
print(f"数据库已备份到: {destination}")
数据清理：
-- 删除30天前的检测记录
DELETE FROM detections
WHERE detected_at < datetime('now', '-30 days');
-- 清理孤立的检测结果
DELETE FROM detection_results
WHERE detection_id NOT IN (SELECT detection_id FROM detections);
7. 系统架构
7.1 整体架构
本系统采用 三层架构 设计，分为表示层、业务逻辑层和数据层。
┌─────────────────────────────────────────────────────────────┐
│ 表示层 (Presentation Layer) │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Web UI │ │ Streamlit │ │ Plotly │ │
│ │ (HTML/CSS) │ │ Components │ │ Charts │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────────────────────────────────────────┘
↕
┌─────────────────────────────────────────────────────────────┐
│ 业务逻辑层 (Business Logic Layer) │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 图片识别 │ │ 批量处理 │ │ 历史管理 │ │
│ │ 模块 │ │ 模块 │ │ 模块 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 模型推理 │ │ 数据分析 │ │ 结果导出 │ │
│ │ 模块 │ │ 模块 │ │ 模块 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────────────────────────────────────────┘
↕
┌─────────────────────────────────────────────────────────────┐
│ 数据层 (Data Layer) │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ YOLOv8 │ │ SQLite │ │ JSON │ │
│ │ Model │ │ Database │ │ Storage │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Image │ │ Config │ │ Logs │ │
│ │ Storage │ │ Files │ │ Files │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
└─────────────────────────────────────────────────────────────┘
7.2 技术架构
前端技术栈：
- Streamlit: Web 应用框架
- Plotly: 交互式图表
- HTML/CSS: 自定义样式
- JavaScript: 前端交互（Streamlit 内置）
后端技术栈：
- Python 3.8+: 主要编程语言
- PyTorch: 深度学习框架
- Ultralytics: YOLOv8 实现
- OpenCV: 图像处理
- NumPy/Pandas: 数据处理
数据存储：
- SQLite: 关系型数据库
- JSON: 历史记录存储
- File System: 图片和模型文件
7.3 模块划分
1. 图片识别模块
class ImageDetection:
def __init__(self, model_path):
self.model = load_model(model_path)
def detect(self, image, conf_threshold, iou_threshold):
# 图片预处理
processed_image = self.preprocess(image)
# 模型推理
results = self.model.predict(
processed_image,
conf=conf_threshold,
iou=iou_threshold
)
# 后处理
detections = self.postprocess(results)
return detections
2. 批量处理模块
class BatchProcessor:
def __init__(self, detector):
self.detector = detector
def process_batch(self, images, callback=None):
results = []
for idx, image in enumerate(images):
result = self.detector.detect(image)
results.append(result)
if callback:
callback(idx + 1, len(images))
return results
3. 历史管理模块
class HistoryManager:
def __init__(self, storage_path):
self.storage_path = storage_path
self.history = self.load_history()
def add_record(self, record):
self.history.insert(0, record)
self.save_history()
def get_records(self, filters=None):
if filters:
return self.filter_records(filters)
return self.history
4. 数据分析模块
class DataAnalyzer:
def __init__(self, history):
self.history = history
def get_class_distribution(self):
# 统计各类别数量
pass
def get_confidence_stats(self):
# 统计置信度分布
pass
def get_time_trends(self):
# 统计时间趋势
pass
7.4 数据流程
单张图片识别流程：
用户上传图片
↓
前端接收 (Streamlit)
↓
图片验证 (格式、大小)
↓
图片预处理 (resize, normalize)
↓
模型推理 (YOLOv8)
↓
结果后处理 (NMS, 坐标转换)
↓
结果可视化 (绘制边界框)
↓
保存历史记录 (JSON/Database)
↓
返回结果给用户
批量识别流程：
用户上传多张图片
↓
前端接收并验证
↓
创建处理队列
↓
循环处理每张图片
├── 图片预处理
├── 模型推理
├── 结果后处理
├── 更新进度条
└── 保存结果
↓
汇总所有结果
↓
生成统计报告
↓
导出 CSV/JSON
↓
返回结果给用户
7.5 性能优化
1. 模型缓存
@st.cache_resource
def load_model(model_path):
"""使用 Streamlit 缓存避免重复加载模型"""
model = YOLO(model_path)
return model
2. 图片预处理优化
def preprocess_image(image, target_size=640):
"""高效的图片预处理"""
# 使用 OpenCV 的快速 resize
resized = cv2.resize(image, (target_size, target_size),
interpolation=cv2.INTER_LINEAR)
# 归一化
normalized = resized.astype(np.float32) / 255.0
return normalized
3. 批量处理优化
def batch_inference(model, images, batch_size=16):
"""批量推理提高效率"""
results = []
for i in range(0, len(images), batch_size):
batch = images[i:i+batch_size]
batch_results = model.predict(batch)
results.extend(batch_results)
return results
4. 数据库查询优化
-- 使用索引加速查询
CREATE INDEX idx_detected_at ON detections(detected_at);
CREATE INDEX idx_user_id ON detections(user_id);
-- 使用 EXPLAIN 分析查询计划
EXPLAIN QUERY PLAN
SELECT * FROM detections WHERE user_id = 1 ORDER BY detected_at DESC;
8. 目录结构
8.1 项目目录树
project_root/
│
├── algorithm/ # 算法和系统实现目录
│ ├── Indian Edible Oil Seed Dataset/ # 原始数据集
│ │ ├── Black Sesame Seeds/ # 黑芝麻图片
│ │ ├── Groundnut Seeds/ # 花生图片
│ │ ├── Linseed/ # 亚麻籽图片
│ │ ├── Mustard Seeds/ # 芥菜籽图片
│ │ ├── Niger Seeds/ # 尼日尔籽图片
│ │ ├── Safflower Seed/ # 红花籽图片
│ │ ├── Soybean seeds/ # 大豆图片
│ │ ├── Sunflower Seeds/ # 葵花籽图片
│ │ └── White Sesame Seeds/ # 白芝麻图片
│ │
│ ├── seed_dataset_yolo/ # YOLO 格式数据集（训练后生成）
│ │ ├── train/ # 训练集
│ │ │ ├── images/ # 训练图片
│ │ │ └── labels/ # 训练标签
│ │ ├── val/ # 验证集
│ │ │ ├── images/ # 验证图片
│ │ │ └── labels/ # 验证标签
│ │ ├── test/ # 测试集
│ │ │ ├── images/ # 测试图片
│ │ │ └── labels/ # 测试标签
│ │ └── data.yaml # 数据集配置文件
│ │
│ ├── runs/ # 训练输出目录（训练后生成）
│ │ └── detect/
│ │ └── seed_detection/ # 训练实验目录
│ │ ├── weights/ # 模型权重
│ │ │ ├── best.pt # 最佳模型
│ │ │ └── last.pt # 最后一轮模型
│ │ ├── results.png # 训练曲线
│ │ ├── confusion_matrix.png # 混淆矩阵
│ │ ├── BoxP_curve.png # Precision 曲线
│ │ ├── BoxR_curve.png # Recall 曲线
│ │ ├── BoxPR_curve.png # PR 曲线
│ │ ├── BoxF1_curve.png # F1 曲线
│ │ └── labels.jpg # 标签分布
│ │
│ ├── algorithm.ipynb # 算法设计与训练 Notebook
│ ├── streamlit_app.py # Streamlit 应用主程序
│ ├── config.yaml # 系统配置文件
│ ├── requirements.txt # Python 依赖包列表
│ ├── detection_history.json # 历史记录文件（运行后生成）
│ │
│ ├── test_system.py # 系统测试脚本
│ ├── test_streamlit.py # Streamlit 测试脚本
│ ├── prepare_demo.py # 演示数据准备脚本
│ │
│ ├── run_system.bat # Windows 启动脚本
│ ├── run_app.bat # 应用启动脚本
│ │
│ ├── README.md # 项目说明文档
│ ├── QUICKSTART.md # 快速入门指南
│ ├── PROJECT_OVERVIEW.md # 项目总览
│ ├── STREAMLIT_GUIDE.txt # Streamlit 功能说明
│ ├── 使用说明.md # 中文使用说明
│ ├── 项目完成说明.txt # 项目完成说明
│ ├── 项目检查清单.md # 项目检查清单
│ ├── START_HERE.md # 开始指南
│ └── .gitignore # Git 忽略规则
│
├── explaination/ # 项目详解目录
│ ├── 详解.md # 项目详细说明文档（本文件）
│ └── images/ # 说明文档图片
│ ├── algorithm/ # 算法相关图片
│ │ ├── BoxF1_curve.png # F1 曲线
│ │ ├── BoxP_curve.png # Precision 曲线
│ │ ├── BoxPR_curve.png # PR 曲线
│ │ ├── BoxR_curve.png # Recall 曲线
│ │ ├── confusion_matrix_normalized.png # 混淆矩阵
│ │ ├── dataset_samples.png # 数据集样本
│ │ ├── labels.jpg # 标签分布
│ │ ├── results.png # 训练结果
│ │ ├── val_batch0_labels.jpg # 验证集批次0
│ │ └── val_batch1_labels.jpg # 验证集批次1
│ └── system/ # 系统界面图片
│ ├── 首页.png # 首页截图
│ ├── 图像识别.png # 图像识别界面
│ ├── 批量识别.png # 批量识别界面
│ ├── 模型分析.png # 模型分析界面
│ ├── 历史记录.png # 历史记录界面
│ └── 系统设置.png # 系统设置界面
│
├── database/ # 数据库目录（可选）
│ ├── seed_detection.db # SQLite 数据库文件
│ └── backup/ # 数据库备份目录
│ └── seed_detection_backup_*.db # 备份文件
│
└── logs/ # 日志目录（可选）
├── app.log # 应用日志
├── error.log # 错误日志
└── detection.log # 检测日志
8.2 核心文件说明
8.2.1 算法相关文件
| 文件名 | 类型 | 大小 | 说明 |
|---|---|---|---|
| algorithm.ipynb | Jupyter Notebook | ~500 KB | 完整的算法设计、数据处理、模型训练流程 |
| yolov8n.pt | PyTorch Model | ~6 MB | 预训练的 YOLOv8n 模型权重 |
| best.pt | PyTorch Model | ~6 MB | 训练后的最佳模型权重 |
| data.yaml | YAML | ~1 KB | 数据集配置文件，包含类别和路径信息 |
8.2.2 系统相关文件
| 文件名 | 类型 | 大小 | 说明 |
|---|---|---|---|
| streamlit_app.py | Python | ~25 KB | Streamlit 应用主程序，包含所有界面和功能 |
| config.yaml | YAML | ~2 KB | 系统配置文件，包含模型、数据集、训练参数 |
| requirements.txt | Text | ~1 KB | Python 依赖包列表 |
| detection_history.json | JSON | 动态 | 历史记录存储文件 |
8.2.3 文档文件
| 文件名 | 类型 | 大小 | 说明 |
|---|---|---|---|
| README.md | Markdown | ~15 KB | 项目完整说明文档（英文） |
| 使用说明.md | Markdown | ~20 KB | 详细使用说明（中文） |
| 详解.md | Markdown | ~100 KB | 项目详细技术文档（本文件） |
| QUICKSTART.md | Markdown | ~10 KB | 5分钟快速入门指南 |
8.3 配置文件详解
8.3.1 config.yaml
# 模型配置
model:
name: "YOLOv8n"
path: "runs/detect/seed_detection/weights/best.pt"
input_size: 640
confidence_threshold: 0.5
iou_threshold: 0.45
# 数据集配置
dataset:
name: "Indian Edible Oil Seed Dataset"
path: "Indian Edible Oil Seed Dataset"
num_classes: 9
classes:
- "Black Sesame Seeds"
- "Groundnut Seeds"
- "Linseed"
- "Mustard Seeds"
- "Niger Seeds"
- "Safflower Seed"
- "Soybean seeds"
- "Sunflower Seeds"
- "White Sesame Seeds"
# 训练配置
training:
epochs: 50
batch_size: 16
optimizer: "SGD"
learning_rate: 0.01
patience: 10
device: "0" # GPU ID 或 "cpu"
workers: 4
augment: true
# 数据划分
split:
train: 0.7
val: 0.2
test: 0.1
# 系统配置
system:
title: "农作物种子种类识别系统"
version: "1.0.0"
author: "YOLOv8 Seed Detection"
description: "基于 YOLOv8 的农作物种子自动识别与分类系统"
8.3.2 data.yaml
# YOLOv8 数据集配置文件
path: D:/project/algorithm/seed_dataset_yolo # 数据集根目录
train: train/images # 训练集图片路径
val: val/images # 验证集图片路径
test: test/images # 测试集图片路径
# 类别数量
nc: 9
# 类别名称
names:
0: Black Sesame Seeds
1: Groundnut Seeds
2: Linseed
3: Mustard Seeds
4: Niger Seeds
5: Safflower Seed
6: Soybean seeds
7: Sunflower Seeds
8: White Sesame Seeds
8.3.3 requirements.txt
# 深度学习框架
torch>=2.0.0
torchvision>=0.15.0
ultralytics>=8.0.0
# 图像处理
opencv-python>=4.8.0
pillow>=10.0.0
# Web 框架
streamlit>=1.28.0
# 数据处理
numpy>=1.24.0
pandas>=2.0.0
# 数据可视化
matplotlib>=3.7.0
plotly>=5.17.0
# 其他工具
pyyaml>=6.0
tqdm>=4.65.0
8.4 文件权限和安全
文件权限设置：
# 只读文件（配置、文档）
chmod 444 config.yaml
chmod 444 README.md
# 可执行文件（脚本）
chmod 755 run_system.bat
chmod 755 test_system.py
# 读写文件（数据库、日志）
chmod 666 detection_history.json
chmod 666 database/seed_detection.db
敏感信息保护：
# 不要在代码中硬编码敏感信息
# 使用环境变量或配置文件
import os
from dotenv import load_dotenv
load_dotenv()
DATABASE_PASSWORD = os.getenv('DB_PASSWORD')
API_KEY = os.getenv('API_KEY')
9. 系统界面
9.1 首页
图 9.1：系统首页界面
首页是用户进入系统后看到的第一个界面，提供系统概览和快速导航功能。
界面组成：
-
顶部标题栏
- 系统名称：农作物种子种类识别系统
- 系统图标：🌾 种子图标
- 渐变背景：绿色主题，体现农业特色
-
统计卡片区（3个指标卡片）
- 支持种子类别：显示系统支持的种子类别数量（9种）
- 历史识别记录：显示累计识别次数
- 模型状态：显示模型是否已加载（✅ 已加载 / ❌ 未找到）
-
功能介绍区（左右两列）
- 左列：
- 📷 图片识别：单张图片识别功能介绍
- 📊 模型分析：模型性能分析功能介绍
- 右列：
- 📁 批量识别：批量处理功能介绍
- 📜 历史记录：历史管理功能介绍
- 左列：
-
种子类别展示区（3×3网格）
- 9个信息卡片，每个展示一种种子
- 包含序号、中文名称和英文名称
- 蓝色背景，清晰易读
-
快速开始指南
- 5步操作指南
- 引导用户快速上手
设计特点：
- 🎨 清新的绿色主题，符合农业场景
- 📊 直观的统计信息展示
- 🧭 清晰的功能导航
- 📱 响应式布局，适配不同屏幕
9.2 图片识别界面
图 9.2：单张图片识别界面
图片识别界面是系统的核心功能之一，提供单张图片的上传和识别功能。
界面布局：
左侧区域（上传区）：
-
上传组件
- 文件选择按钮：“Browse files”
- 支持格式：JPG、JPEG、PNG
- 拖拽上传支持
-
原始图片预览
- 显示上传的原始图片
- 图片标题：“原始图片”
- 自适应容器宽度
-
图片信息卡片
- 文件名：显示上传的文件名
- 尺寸：显示图片的宽×高
- 格式：显示图片格式（JPEG/PNG）
- 大小：显示文件大小（KB）
-
识别按钮
- 🔍 开始识别按钮
- 主要按钮样式（蓝色）
- 全宽显示
右侧区域（结果区）：
-
结果图片
- 显示带检测框的结果图片
- 绿色边界框标注检测到的种子
- 类别标签和置信度显示
-
成功提示
- ✅ 成功检测到 X 个种子目标
- 绿色背景提示框
-
检测详情（可展开）
- 每个检测目标一个展开面板
- 显示内容：
- 目标序号
- 种子类别（中文）
- 英文名称
- 置信度（百分比）
- 置信度进度条（可视化）
-
下载按钮
- 📥 下载结果图片
- 保存带检测框的结果图片
交互流程：
1. 用户上传图片
↓
2. 显示原始图片和信息
↓
3. 点击"开始识别"按钮
↓
4. 显示加载动画："正在识别中..."
↓
5. 显示结果图片和检测详情
↓
6. 用户可下载结果或继续识别
功能特点：
- 🖼️ 实时图片预览
- 📊 详细的检测信息
- 📥 结果图片下载
- 💾 自动保存到历史记录
- ⚡ 快速响应，用户体验好
9.3 批量识别界面
图 9.3：批量图片识别界面
批量识别界面支持同时处理多张图片，适合大规模识别任务。
界面组成：
-
文件上传区
- 多文件选择器
- 支持同时上传多张图片
- 显示已上传图片数量
-
图片预览区（可展开）
- 5列网格布局
- 显示前10张图片的缩略图
- 超过10张显示提示信息
-
选项配置区（3列）
- ☑️ 保存结果图片：是否保存带检测框的图片
- ☑️ 显示详细信息：是否显示详细结果表格
- ☑️ 自动下载报告：完成后自动下载报告
-
批量识别按钮
- 🚀 开始批量识别
- 主要按钮样式
- 全宽显示
-
进度显示区
- 进度条：显示处理进度
- 状态文本：显示当前处理的文件
- 实时更新
-
统计指标区（4个指标）
- 总检测数：检测到的目标总数
- 图片数：处理的图片数量
- 平均置信度：所有检测的平均置信度
- 种子类别数：检测到的不同类别数
-
结果表格
- 序号、文件名、种子类别、英文名称、置信度、检测时间
- 可排序、可筛选
- 全宽显示
-
类别分布图表
- 柱状图：显示各类别的检测数量
- 交互式图表（Plotly）
- 可缩放、可导出
-
下载按钮区（2列）
- 📥 下载结果 (CSV)：导出 CSV 格式报告
- 📥 下载结果 (JSON)：导出 JSON 格式报告
批量处理流程：
1. 上传多张图片
↓
2. 预览图片（可选）
↓
3. 配置选项
↓
4. 点击"开始批量识别"
↓
5. 显示进度条和状态
↓
6. 逐张处理图片
├── 更新进度
└── 保存结果
↓
7. 显示统计指标
↓
8. 显示结果表格和图表
↓
9. 下载报告
功能特点：
- 📁 支持多文件上传
- 📊 实时进度显示
- 📈 可视化统计分析
- 📥 多格式导出（CSV/JSON）
- ⚡ 高效批量处理
9.4 模型分析界面
图 9.4：模型性能分析界面
模型分析界面提供全面的模型性能评估和数据统计分析功能。
界面结构：
-
模型信息区（4个指标）
- 模型类型：YOLOv8n
- 模型大小：6.2 MB
- 输入尺寸：640×640
- 类别数量：9
-
模型路径信息
- 显示模型文件的完整路径
- 蓝色信息框
-
统计指标区（4个指标）
- 总识别次数：历史记录总数
- 总检测目标：检测到的目标总数
- 平均置信度：所有检测的平均置信度
- 最高置信度：最高的置信度值
-
分析标签页（4个Tab）
Tab 1 - 📊 类别分布
-
左侧：柱状图
- 横轴：种子类别
- 纵轴：检测次数
- 显示各类别的检测频率
-
右侧：饼图
- 显示各类别的占比
- 彩色扇形区域
- 百分比标注
Tab 2 - 📈 置信度分析
-
左侧：直方图
- 横轴：置信度值（0-1）
- 纵轴：数量
- 20个区间
- 显示置信度分布
-
右侧：箱线图
- 横轴：种子类别
- 纵轴：置信度
- 显示每个类别的置信度分布
- 包含中位数、四分位数、异常值
-
置信度区间统计
- 低 (0-0.5)
- 中 (0.5-0.7)
- 高 (0.7-0.85)
- 很高 (0.85-1.0)
- 柱状图显示各区间的数量
Tab 3 - ⏰ 时间趋势
-
每日识别趋势
- 折线图
- 横轴：日期
- 纵轴：识别次数
- 显示每天的识别活动
-
24小时识别分布
- 柱状图
- 横轴：小时（0-23）
- 纵轴：识别次数
- 显示一天中的识别高峰时段
Tab 4 - 🎯 详细统计
-
统计表格
- 列：种子类别、检测次数、平均置信度、最低置信度、最高置信度、标准差
- 按检测次数降序排列
- 全宽显示
-
下载统计报告
- 📥 下载统计报告 (JSON)
- 包含完整的统计信息
功能特点：
- 📊 多维度数据可视化
- 📈 交互式图表（Plotly）
- 📉 详细的统计分析
- 📥 报告导出功能
- 🔍 深入的性能洞察
9.5 历史记录界面
图 9.5：识别历史记录界面
历史记录界面提供完整的识别历史查看、筛选和管理功能。
界面组成：
-
筛选选项区（3列）
-
筛选种子类别：多选下拉框
- 可选择一个或多个类别
- 默认显示全部类别
-
时间范围：单选下拉框
- 全部
- 今天
- 最近7天
- 最近30天
-
排序方式：单选下拉框
- 时间降序（最新在前）
- 时间升序（最旧在前）
- 置信度降序
- 置信度升序
-
-
搜索框
- 🔍 搜索文件名
- 输入关键词实时筛选
- 占位符提示
-
统计信息区（3个指标）
- 筛选结果：符合条件的记录数
- 检测目标：筛选结果中的目标总数
- 平均置信度：筛选结果的平均置信度
-
分页控制
- 页码输入框
- 显示当前页和总页数
- 每页显示10条记录
-
记录列表
- 每条记录一个可展开面板
- 面板标题：序号 - 文件名 - 时间
- 展开后显示：
- 左侧（2/3宽度）：
- 📷 文件名
- ⏰ 时间
- ⚙️ 置信度阈值
- 🎯 检测数量
- 右侧（1/3宽度）：
- 🗑️ 删除按钮
- 检测详情表格：
- 序号、种子类别、英文名称、置信度
- 表格形式展示
- 左侧（2/3宽度）：
-
批量操作区（3列）
- 📥 导出全部历史：导出所有历史记录
- 📥 导出筛选结果：导出当前筛选的记录
- 🗑️ 清空全部历史：删除所有记录（需确认）
-
确认清空选项
- ☑️ 确认清空（此操作不可恢复）
- 安全机制，防止误删
筛选逻辑：
# 按类别筛选
if selected_classes:
records = filter_by_classes(records, selected_classes)
# 按时间筛选
if date_filter != "全部":
records = filter_by_date(records, date_filter)
# 按文件名搜索
if search_query:
records = filter_by_filename(records, search_query)
# 排序
records = sort_records(records, sort_by)
# 分页
page_records = paginate(records, page_num, items_per_page)
功能特点：
- 🔍 强大的筛选功能
- 📄 分页显示，性能优化
- 🗑️ 单条删除和批量清空
- 📥 多格式导出
- 🔒 安全确认机制
9.6 系统设置界面
图 9.6：系统设置界面
系统设置界面提供模型配置、显示设置、数据管理和系统信息查看功能。
界面结构：
-
模型设置区（可展开）
- 左列：
- 模型路径：文本输入框（只读）
- 默认置信度阈值：数字输入框（0.0-1.0）
- 右列：
- 输入图像尺寸：数字输入框（步长32）
- 默认 IOU 阈值：数字输入框（0.0-1.0）
- 左列：
-
显示设置区（可展开）
- 左列：
- 主题颜色：下拉选择框
- 绿色（默认）
- 蓝色
- 紫色
- 橙色
- 语言：下拉选择框
- 中文
- English
- 主题颜色：下拉选择框
- 右列：
- 历史记录保留数量：数字输入框（10-1000）
- ☑️ 显示调试信息：复选框
- 左列：
-
数据管理区（可展开）
-
统计指标（3列）：
- 历史记录数
- 历史文件大小（KB）
- 本次会话识别
-
操作按钮（2列）：
- 🔄 重置会话统计
- 🗑️ 清空所有数据（需确认）
-
-
系统信息区（可展开）
- 环境信息：
- Python 版本
- 操作系统
- 系统版本
- 处理器
- Streamlit 版本
- PyTorch 版本
- CUDA 可用
- CUDA 版本（如果可用）
- GPU 设备（如果可用）
- Ultralytics 版本
- 环境信息：
-
关于系统区
- 系统名称和版本
- 功能特点列表
- 技术栈信息
- 版权信息
-
快捷操作区（3列）
- 🔄 重新加载模型：清除模型缓存并重新加载
- 📥 导出配置：导出系统配置为 JSON 文件
- 🔄 刷新页面：重新加载整个应用
功能特点：
- ⚙️ 完整的配置管理
- 📊 详细的系统信息
- 💾 数据管理功能
- 🔧 快捷操作按钮
- 🔒 安全确认机制
10. 功能详解
10.1 图片识别功能
功能描述：
单张图片识别是系统的核心功能，用户上传一张种子图片，系统自动检测并识别图片中的种子类别。
技术实现：
def detect_single_image(image, model, conf_threshold, iou_threshold):
"""
单张图片识别函数
参数:
image: PIL Image 对象
model: YOLOv8 模型
conf_threshold: 置信度阈值
iou_threshold: IOU 阈值
返回:
result: 检测结果对象
"""
# 1. 图片预处理
img_array = np.array(image)
# 2. 模型推理
results = model.predict(
source=img_array,
conf=conf_threshold,
iou=iou_threshold,
verbose=False
)
# 3. 返回结果
return results[0]
处理流程：
-
图片上传
uploaded_file = st.file_uploader( "选择种子图片", type=['jpg', 'jpeg', 'png'] ) -
图片验证
# 检查文件大小 if uploaded_file.size > 10 * 1024 * 1024: # 10MB st.error("文件过大，请上传小于10MB的图片") return # 检查图片格式 try: image = Image.open(uploaded_file) except: st.error("无效的图片文件") return -
模型推理
# 加载模型（使用缓存） model = load_model(model_path) # 执行推理 result = model.predict(image, conf=0.5, iou=0.45) -
结果处理
# 提取检测结果 boxes = result.boxes for box in boxes: cls_id = int(box.cls[0]) conf = float(box.conf[0]) bbox = box.xyxy[0].tolist() # 保存结果 detections.append({ 'class': SEED_CLASSES[cls_id], 'confidence': conf, 'bbox': bbox }) -
结果可视化
# 绘制检测框 result_img = result.plot() # 显示结果 st.image(result_img, caption="检测结果") -
保存历史
# 添加到历史记录 add_to_history( image_name=uploaded_file.name, results=result, confidence=conf_threshold )
性能优化：
- 使用
@st.cache_resource缓存模型，避免重复加载 - 图片预处理使用 OpenCV 加速
- 异步处理，不阻塞界面
10.2 批量识别功能
功能描述：
批量识别允许用户同时上传多张图片，系统自动逐张处理并生成汇总报告。
技术实现：
def batch_detection(files, model, conf_threshold, iou_threshold, callback=None):
"""
批量图片识别函数
参数:
files: 文件列表
model: YOLOv8 模型
conf_threshold: 置信度阈值
iou_threshold: IOU 阈值
callback: 进度回调函数
返回:
results: 所有检测结果列表
"""
results = []
for idx, file in enumerate(files):
# 读取图片
image = Image.open(file)
# 执行检测
result = model.predict(
image,
conf=conf_threshold,
iou=iou_threshold
)
# 保存结果
results.append({
'filename': file.name,
'detections': result[0].boxes
})
# 更新进度
if callback:
callback(idx + 1, len(files))
return results
处理流程：
-
多文件上传
uploaded_files = st.file_uploader( "选择多张种子图片", type=['jpg', 'jpeg', 'png'], accept_multiple_files=True ) -
进度显示
progress_bar = st.progress(0) status_text = st.empty() def update_progress(current, total): progress = current / total progress_bar.progress(progress) status_text.text(f"正在处理: {current}/{total}") -
批量处理
results_data = [] for idx, file in enumerate(uploaded_files): # 处理单张图片 image = Image.open(file) result = model.predict(image) # 提取结果 for box in result[0].boxes: results_data.append({ '文件名': file.name, '种子类别': get_class_name(box.cls), '置信度': f"{box.conf:.2%}" }) # 更新进度 update_progress(idx + 1, len(uploaded_files)) -
结果汇总
# 创建 DataFrame df = pd.DataFrame(results_data) # 显示表格 st.dataframe(df, use_container_width=True) # 统计分析 st.metric("总检测数", len(df)) st.metric("平均置信度", f"{df['置信度值'].mean():.2%}") -
数据导出
# 导出 CSV csv = df.to_csv(index=False, encoding='utf-8-sig') st.download_button( label="📥 下载结果 (CSV)", data=csv, file_name=f"batch_results_{timestamp}.csv", mime="text/csv" ) # 导出 JSON json_data = df.to_json(orient='records', force_ascii=False) st.download_button( label="📥 下载结果 (JSON)", data=json_data, file_name=f"batch_results_{timestamp}.json", mime="application/json" )
性能优化：
- 使用生成器处理大批量文件
- 分批次处理，避免内存溢出
- 异步 I/O 操作
10.3 历史记录功能
功能描述：
历史记录功能自动保存每次识别操作，支持查看、筛选、搜索和导出。
数据结构：
# 历史记录格式
history_record = {
'timestamp': '2024-01-01 12:00:00',
'image_name': 'test.jpg',
'detections': [
{
'class': 'Black Sesame Seeds',
'class_cn': '黑芝麻',
'confidence': 0.95
}
],
'confidence_threshold': 0.5
}
技术实现：
-
保存历史
def add_to_history(image_name, results, confidence): """添加到历史记录""" record = { 'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), 'image_name': image_name, 'detections': [], 'confidence_threshold': confidence } # 提取检测结果 for box in results.boxes: cls_id = int(box.cls[0]) conf = float(box.conf[0]) record['detections'].append({ 'class': SEED_CLASSES[cls_id], 'class_cn': SEED_CLASSES_CN[SEED_CLASSES[cls_id]], 'confidence': conf }) # 添加到历史 st.session_state.history.insert(0, record) # 限制历史记录数量 if len(st.session_state.history) > 100: st.session_state.history = st.session_state.history[:100] # 保存到文件 save_history(st.session_state.history) -
加载历史
def load_history(): """加载历史记录""" if os.path.exists(HISTORY_FILE): try: with open(HISTORY_FILE, 'r', encoding='utf-8') as f: return json.load(f) except: return [] return [] -
筛选功能
def filter_history(history, filters): """筛选历史记录""" filtered = history.copy() # 按类别筛选 if filters.get('classes'): filtered = [ r for r in filtered if any(d['class_cn'] in filters['classes'] for d in r['detections']) ] # 按时间筛选 if filters.get('date_range'): cutoff = get_cutoff_date(filters['date_range']) filtered = [ r for r in filtered if datetime.strptime(r['timestamp'], '%Y-%m-%d %H:%M:%S') >= cutoff ] # 按文件名搜索 if filters.get('search_query'): query = filters['search_query'].lower() filtered = [ r for r in filtered if query in r['image_name'].lower() ] return filtered -
排序功能
def sort_history(history, sort_by): """排序历史记录""" if sort_by == "时间降序": return sorted(history, key=lambda x: x['timestamp'], reverse=True) elif sort_by == "时间升序": return sorted(history, key=lambda x: x['timestamp']) elif sort_by == "置信度降序": return sorted( history, key=lambda x: max([d['confidence'] for d in x['detections']]), reverse=True ) elif sort_by == "置信度升序": return sorted( history, key=lambda x: max([d['confidence'] for d in x['detections']]) ) -
分页功能
def paginate(items, page_num, items_per_page=10): """分页显示""" start_idx = (page_num - 1) * items_per_page end_idx = start_idx + items_per_page return items[start_idx:end_idx]
10.4 模型分析功能
功能描述：
模型分析功能提供全面的数据统计和可视化分析，帮助用户了解模型性能和识别情况。
技术实现：
-
类别分布分析
def analyze_class_distribution(history): """分析类别分布""" # 提取所有检测结果 all_detections = [] for record in history: for det in record['detections']: all_detections.append(det['class_cn']) # 统计各类别数量 class_counts = pd.Series(all_detections).value_counts() # 创建柱状图 fig_bar = px.bar( x=class_counts.index, y=class_counts.values, labels={'x': '种子类别', 'y': '检测次数'}, title='各类别检测次数' ) # 创建饼图 fig_pie = px.pie( values=class_counts.values, names=class_counts.index, title='类别占比分布' ) return fig_bar, fig_pie -
置信度分析
def analyze_confidence(history): """分析置信度分布""" # 提取所有置信度 confidences = [] classes = [] for record in history: for det in record['detections']: confidences.append(det['confidence']) classes.append(det['class_cn']) df = pd.DataFrame({ 'confidence': confidences, 'class': classes }) # 直方图 fig_hist = px.histogram( df, x='confidence', nbins=20, title='置信度分布直方图' ) # 箱线图 fig_box = px.box( df, x='class', y='confidence', title='各类别置信度箱线图' ) return fig_hist, fig_box -
时间趋势分析
def analyze_time_trends(history): """分析时间趋势""" # 提取时间戳 timestamps = [ datetime.strptime(r['timestamp'], '%Y-%m-%d %H:%M:%S') for r in history ] # 按日期统计 df = pd.DataFrame({'timestamp': timestamps}) df['date'] = df['timestamp'].dt.date daily_counts = df.groupby('date').size().reset_index(name='count') # 折线图 fig_trend = px.line( daily_counts, x='date', y='count', title='每日识别次数趋势', markers=True ) # 按小时统计 df['hour'] = df['timestamp'].dt.hour hourly_counts = df.groupby('hour').size().reset_index(name='count') # 柱状图 fig_hour = px.bar( hourly_counts, x='hour', y='count', title='24小时识别分布' ) return fig_trend, fig_hour -
详细统计
def get_detailed_statistics(history): """获取详细统计信息""" # 提取所有检测结果 all_detections = [] for record in history: for det in record['detections']: all_detections.append({ 'class': det['class_cn'], 'confidence': det['confidence'] }) df = pd.DataFrame(all_detections) # 按类别统计 stats = df.groupby('class').agg({ 'confidence': ['count', 'mean', 'min', 'max', 'std'] }).round(4) stats.columns = ['检测次数', '平均置信度', '最低置信度', '最高置信度', '标准差'] return stats
10.5 系统设置功能
功能描述：
系统设置功能提供模型配置、显示设置、数据管理和系统信息查看。
技术实现：
-
模型配置
# 模型路径配置 model_path = st.text_input( "模型路径", value="runs/detect/seed_detection/weights/best.pt" ) # 置信度阈值 confidence = st.slider( "置信度阈值", min_value=0.0, max_value=1.0, value=0.5, step=0.05 ) # IOU 阈值 iou_threshold = st.slider( "IOU 阈值", min_value=0.0, max_value=1.0, value=0.45, step=0.05 ) -
数据管理
# 统计信息 st.metric("历史记录数", len(st.session_state.history)) if os.path.exists(HISTORY_FILE): file_size = os.path.getsize(HISTORY_FILE) / 1024 st.metric("历史文件大小", f"{file_size:.2f} KB") # 重置会话统计 if st.button("🔄 重置会话统计"): st.session_state.detection_count = 0 st.success("✅ 会话统计已重置") st.rerun() # 清空所有数据 if st.button("🗑️ 清空所有数据"): if st.checkbox("确认清空所有数据（不可恢复）"): st.session_state.history = [] st.session_state.detection_count = 0 save_history([]) st.success("✅ 所有数据已清空") st.rerun() -
系统信息
import sys import platform # 获取系统信息 info_data = { "Python 版本": sys.version.split()[0], "操作系统": platform.system(), "系统版本": platform.version(), "处理器": platform.processor(), "Streamlit 版本": st.__version__, } # 获取 PyTorch 信息 try: import torch info_data["PyTorch 版本"] = torch.__version__ info_data["CUDA 可用"] = "是" if torch.cuda.is_available() else "否" if torch.cuda.is_available(): info_data["CUDA 版本"] = torch.version.cuda info_data["GPU 设备"] = torch.cuda.get_device_name(0) except: info_data["PyTorch"] = "未安装" # 显示信息 for key, value in info_data.items(): st.text(f"{key}: {value}") -
配置导出
if st.button("📥 导出配置"): config = { 'model_path': model_path, 'confidence': confidence, 'iou_threshold': iou_threshold, 'seed_classes': SEED_CLASSES, 'export_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S') } config_json = json.dumps(config, ensure_ascii=False, indent=2) st.download_button( label="下载配置文件", data=config_json, file_name="system_config.json", mime="application/json" )
11. 技术实现
11.1 Streamlit 框架
Streamlit 简介：
Streamlit 是一个开源的 Python 库，用于快速创建数据科学和机器学习应用的 Web 界面。
核心特性：
- 🚀 快速开发：纯 Python 代码，无需 HTML/CSS/JavaScript
- 🔄 实时更新：代码修改后自动刷新
- 📊 丰富组件：内置多种 UI 组件和图表
- 💾 状态管理：Session State 管理应用状态
- 🎨 自定义样式：支持 CSS 和 HTML 自定义
基本用法：
import streamlit as st
# 页面配置
st.set_page_config(
page_title="应用标题",
page_icon="🌾",
layout="wide"
)
# 标题
st.title("主标题")
st.header("二级标题")
st.subheader("三级标题")
# 文本
st.text("普通文本")
st.markdown("**Markdown** 文本")
st.write("通用输出")
# 输入组件
text_input = st.text_input("文本输入")
number_input = st.number_input("数字输入")
slider_value = st.slider("滑块", 0, 100, 50)
checkbox = st.checkbox("复选框")
radio = st.radio("单选", ["选项1", "选项2"])
selectbox = st.selectbox("下拉框", ["选项1", "选项2"])
# 按钮
if st.button("点击按钮"):
st.write("按钮被点击")
# 文件上传
uploaded_file = st.file_uploader("上传文件")
# 显示图片
st.image(image, caption="图片标题")
# 显示数据
st.dataframe(df) # 数据框
st.table(df) # 静态表格
st.json(data) # JSON 数据
# 图表
st.line_chart(data)
st.bar_chart(data)
st.plotly_chart(fig)
# 布局
col1, col2 = st.columns(2)
with col1:
st.write("左列")
with col2:
st.write("右列")
# 侧边栏
with st.sidebar:
st.write("侧边栏内容")
# 标签页
tab1, tab2 = st.tabs(["标签1", "标签2"])
with tab1:
st.write("标签1内容")
# 展开面板
with st.expander("展开查看"):
st.write("隐藏内容")
# 进度条
progress_bar = st.progress(0)
for i in range(100):
progress_bar.progress(i + 1)
# 状态消息
st.success("成功消息")
st.info("信息消息")
st.warning("警告消息")
st.error("错误消息")
# Session State
if 'count' not in st.session_state:
st.session_state.count = 0
if st.button("增加"):
st.session_state.count += 1
st.write(f"计数: {st.session_state.count}")
11.2 YOLOv8 集成
Ultralytics 库使用：
from ultralytics import YOLO
# 1. 加载模型
model = YOLO('yolov8n.pt') # 预训练模型
model = YOLO('best.pt') # 自定义模型
# 2. 训练模型
results = model.train(
data='data.yaml',
epochs=50,
imgsz=640,
batch=16,
name='experiment'
)
# 3. 验证模型
metrics = model.val()
print(f"mAP50: {metrics.box.map50}")
print(f"mAP50-95: {metrics.box.map}")
# 4. 预测
results = model.predict(
source='image.jpg',
conf=0.5,
iou=0.45,
save=True
)
# 5. 导出模型
model.export(format='onnx')
# 6. 处理结果
for result in results:
boxes = result.boxes
for box in boxes:
# 边界框坐标
xyxy = box.xyxy[0].tolist()
# 类别和置信度
cls = int(box.cls[0])
conf = float(box.conf[0])
print(f"类别: {cls}, 置信度: {conf:.2f}")
模型缓存优化：
@st.cache_resource
def load_model(model_path):
"""
使用 Streamlit 缓存加载模型
只在第一次调用时加载，后续直接使用缓存
"""
model = YOLO(model_path)
return model
# 使用
model = load_model('best.pt')
11.3 图像处理
OpenCV 图像处理：
import cv2
import numpy as np
# 读取图片
image = cv2.imread('image.jpg')
# 调整大小
resized = cv2.resize(image, (640, 640))
# 颜色空间转换
rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 图像增强
# 亮度调整
bright = cv2.convertScaleAbs(image, alpha=1.2, beta=30)
# 对比度调整
contrast = cv2.convertScaleAbs(image, alpha=1.5, beta=0)
# 高斯模糊
blurred = cv2.GaussianBlur(image, (5, 5), 0)
# 边缘检测
edges = cv2.Canny(gray, 100, 200)
# 绘制边界框
def draw_bbox(image, bbox, label, confidence, color=(0, 255, 0)):
"""绘制边界框"""
x1, y1, x2, y2 = map(int, bbox)
# 绘制矩形
cv2.rectangle(image, (x1, y1), (x2, y2), color, 2)
# 绘制标签
text = f"{label} {confidence:.2f}"
(text_width, text_height), _ = cv2.getTextSize(
text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1
)
cv2.rectangle(
image,
(x1, y1 - text_height - 10),
(x1 + text_width, y1),
color,
-1
)
cv2.putText(
image,
text,
(x1, y1 - 5),
cv2.FONT_HERSHEY_SIMPLEX,
0.5,
(255, 255, 255),
1
)
return image
# 保存图片
cv2.imwrite('output.jpg', image)
PIL 图像处理：
from PIL import Image, ImageDraw, ImageFont
# 打开图片
image = Image.open('image.jpg')
# 调整大小
resized = image.resize((640, 640))
# 旋转
rotated = image.rotate(90)
# 裁剪
cropped = image.crop((100, 100, 400, 400))
# 转换格式
image_rgb = image.convert('RGB')
# 绘制
draw = ImageDraw.Draw(image)
draw.rectangle([100, 100, 200, 200], outline='red', width=2)
draw.text((100, 80), "Label", fill='red')
# 保存
image.save('output.jpg')
# 转换为 NumPy 数组
img_array = np.array(image)
# 从 NumPy 数组创建
image = Image.fromarray(img_array)
11.4 数据可视化
Plotly 交互式图表：
import plotly.express as px
import plotly.graph_objects as go
# 柱状图
fig = px.bar(
x=['A', 'B', 'C'],
y=[10, 20, 15],
labels={'x': 'Category', 'y': 'Value'},
title='Bar Chart'
)
st.plotly_chart(fig)
# 折线图
fig = px.line(
df,
x='date',
y='value',
title='Line Chart',
markers=True
)
st.plotly_chart(fig)
# 饼图
fig = px.pie(
values=[30, 40, 30],
names=['A', 'B', 'C'],
title='Pie Chart'
)
st.plotly_chart(fig)
# 散点图
fig = px.scatter(
df,
x='x',
y='y',
color='category',
title='Scatter Plot'
)
st.plotly_chart(fig)
# 箱线图
fig = px.box(
df,
x='category',
y='value',
title='Box Plot'
)
st.plotly_chart(fig)
# 直方图
fig = px.histogram(
df,
x='value',
nbins=20,
title='Histogram'
)
st.plotly_chart(fig)
# 自定义图表
fig = go.Figure()
fig.add_trace(go.Bar(x=['A', 'B', 'C'], y=[10, 20, 15]))
fig.update_layout(title='Custom Chart')
st.plotly_chart(fig)
Matplotlib 图表：
import matplotlib.pyplot as plt
# 创建图表
fig, ax = plt.subplots(figsize=(10, 6))
# 绘制
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_title('Title')
# 显示
st.pyplot(fig)
11.5 数据持久化
JSON 存储：
import json
# 保存数据
data = {
'key1': 'value1',
'key2': [1, 2, 3],
'key3': {'nested': 'dict'}
}
with open('data.json', 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
# 读取数据
with open('data.json', 'r', encoding='utf-8') as f:
data = json.load(f)
SQLite 数据库：
import sqlite3
# 连接数据库
conn = sqlite3.connect('database.db')
cursor = conn.cursor()
# 创建表
cursor.execute('''
CREATE TABLE IF NOT EXISTS records (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
value REAL,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)
''')
# 插入数据
cursor.execute(
'INSERT INTO records (name, value) VALUES (?, ?)',
('test', 123.45)
)
conn.commit()
# 查询数据
cursor.execute('SELECT * FROM records')
rows = cursor.fetchall()
# 关闭连接
conn.close()
Pandas 数据处理：
import pandas as pd
# 创建 DataFrame
df = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
})
# 保存为 CSV
df.to_csv('data.csv', index=False, encoding='utf-8-sig')
# 读取 CSV
df = pd.read_csv('data.csv')
# 保存为 Excel
df.to_excel('data.xlsx', index=False)
# 读取 Excel
df = pd.read_excel('data.xlsx')
# 保存为 JSON
df.to_json('data.json', orient='records', force_ascii=False)
# 读取 JSON
df = pd.read_json('data.json')
11.6 错误处理
异常处理：
try:
# 尝试执行的代码
model = YOLO(model_path)
result = model.predict(image)
except FileNotFoundError:
st.error("❌ 模型文件未找到")
except Exception as e:
st.error(f"❌ 发生错误: {str(e)}")
# 记录错误日志
logging.error(f"Error: {e}", exc_info=True)
else:
# 没有异常时执行
st.success("✅ 操作成功")
finally:
# 无论是否异常都执行
cleanup()
输入验证：
def validate_image(uploaded_file):
"""验证上传的图片"""
# 检查文件是否存在
if uploaded_file is None:
return False, "请上传图片"
# 检查文件大小
if uploaded_file.size > 10 * 1024 * 1024: # 10MB
return False, "文件过大，请上传小于10MB的图片"
# 检查文件格式
if uploaded_file.type not in ['image/jpeg', 'image/png', 'image/jpg']:
return False, "不支持的文件格式，请上传 JPG 或 PNG 图片"
# 尝试打开图片
try:
image = Image.open(uploaded_file)
# 检查图片尺寸
if image.size[0] < 100 or image.size[1] < 100:
return False, "图片尺寸过小，请上传至少 100×100 的图片"
except:
return False, "无效的图片文件"
return True, "验证通过"
# 使用
is_valid, message = validate_image(uploaded_file)
if not is_valid:
st.error(message)
return
11.7 性能优化技巧
1. 缓存机制：
# 缓存数据
@st.cache_data
def load_data():
"""缓存数据加载"""
return pd.read_csv('large_file.csv')
# 缓存资源
@st.cache_resource
def load_model():
"""缓存模型加载"""
return YOLO('model.pt')
2. 异步处理：
import asyncio
async def process_image_async(image):
"""异步处理图片"""
# 模拟耗时操作
await asyncio.sleep(1)
return result
# 使用
result = asyncio.run(process_image_async(image))
3. 批量处理：
def batch_process(items, batch_size=16):
"""批量处理"""
results = []
for i in range(0, len(items), batch_size):
batch = items[i:i+batch_size]
batch_results = model.predict(batch)
results.extend(batch_results)
return results
4. 内存优化：
# 使用生成器
def process_large_dataset(files):
"""使用生成器处理大数据集"""
for file in files:
image = load_image(file)
result = process_image(image)
yield result
# 释放内存
del image
# 使用
for result in process_large_dataset(files):
save_result(result)
12. 使用说明
12.1 环境准备
系统要求：
- 操作系统：Windows 10/11, Linux, macOS
- Python 版本：3.8 或更高
- 内存：8GB+ 推荐
- 硬盘空间：10GB+
- GPU：可选（NVIDIA GPU with CUDA support）
安装步骤：
-
安装 Python
# 检查 Python 版本 python --version # 应显示 Python 3.8 或更高版本 -
克隆项目（如果使用 Git）
git clone <repository-url> cd project_root -
安装依赖包
cd algorithm pip install -r requirements.txt -
验证安装
python test_system.py
12.2 模型训练
步骤 1：准备数据集
数据集已包含在项目中，位于 algorithm/Indian Edible Oil Seed Dataset/ 目录。
步骤 2：打开 Jupyter Notebook
# 方法 1：使用 Jupyter Notebook
jupyter notebook algorithm.ipynb
# 方法 2：使用 JupyterLab
jupyter lab algorithm.ipynb
# 方法 3：使用 VS Code
# 直接在 VS Code 中打开 algorithm.ipynb
步骤 3：运行训练流程
在 Jupyter Notebook 中，依次执行以下步骤：
-
环境配置与依赖安装
- 运行第一个单元格安装必要的库
-
数据集准备与预处理
- 统计数据集信息
- 可视化数据集样本
-
转换为 YOLO 格式
- 创建 YOLO 目录结构
- 生成标注文件
- 划分训练集/验证集/测试集
-
YOLOv8 模型训练
- 加载预训练模型
- 配置训练参数
- 开始训练（约 30-60 分钟）
-
模型评估与测试
- 在验证集上评估
- 查看训练曲线
- 分析混淆矩阵
-
模型导出
- 保存最佳模型
- 导出为 ONNX 格式（可选）
训练参数调整：
如果需要快速测试，可以修改训练参数：
# 在 algorithm.ipynb 中修改
results = model.train(
data=yaml_path,
epochs=10, # 减少训练轮数（原来是 50）
batch=8, # 减小批次大小（原来是 16）
imgsz=640,
name='seed_detection_test'
)
12.3 启动系统
方法 1：Windows 快速启动
双击运行 run_app.bat 文件。
方法 2：命令行启动
cd algorithm
streamlit run streamlit_app.py
方法 3：指定端口启动
streamlit run streamlit_app.py --server.port 8502
方法 4：后台运行
# Linux/macOS
nohup streamlit run streamlit_app.py &
# Windows
start /B streamlit run streamlit_app.py
系统启动后，浏览器会自动打开 http://localhost:8501。
12.4 使用流程
单张图片识别：
- 点击左侧导航栏的 “📷 图片识别”
- 点击 “Browse files” 上传图片
- 查看原始图片和图片信息
- 点击 “🔍 开始识别” 按钮
- 查看识别结果和检测详情
- 可选：下载结果图片
批量图片识别：
- 点击左侧导航栏的 “📁 批量识别”
- 上传多张图片（按住 Ctrl 多选）
- 配置选项（保存图片、显示详情等）
- 点击 “🚀 开始批量识别” 按钮
- 等待处理完成
- 查看结果表格和统计图表
- 下载 CSV 或 JSON 报告
查看历史记录：
- 点击左侧导航栏的 “📜 历史记录”
- 使用筛选器过滤记录
- 使用搜索框查找特定文件
- 展开记录查看详情
- 可选：导出历史记录或删除记录
模型分析：
- 点击左侧导航栏的 “📊 模型分析”
- 查看模型信息和统计指标
- 切换不同的分析标签页
- 查看类别分布、置信度分析、时间趋势
- 可选：下载统计报告
系统设置：
- 点击左侧导航栏的 “⚙️ 系统设置”
- 配置模型参数
- 调整显示设置
- 管理数据（重置、清空）
- 查看系统信息
- 可选：导出配置文件
12.5 常见问题
Q1: 模型加载失败？
A: 检查以下几点：
- 确保已完成模型训练
- 检查模型路径是否正确
- 确认模型文件
best.pt存在
# 检查模型文件
ls runs/detect/seed_detection/weights/best.pt
Q2: 识别速度很慢？
A: 可能的原因和解决方案：
- 使用 CPU 推理：考虑使用 GPU 加速
- 图片过大：调整图片大小
- 批次大小过小：增加批次大小
# 在侧边栏调整置信度阈值
# 降低阈值可能会提高速度但降低精度
Q3: 识别结果不准确？
A: 尝试以下方法：
- 调整置信度阈值（降低到 0.3-0.4）
- 使用更清晰的图片
- 确保光线充足
- 避免种子重叠过多
Q4: 历史记录丢失？
A: 历史记录保存在 detection_history.json 文件中：
- 检查文件是否存在
- 检查文件权限
- 定期备份历史文件
# 备份历史记录
cp detection_history.json detection_history_backup.json
Q5: 系统无法启动？
A: 检查以下几点：
- 确认 Streamlit 已安装
- 检查端口是否被占用
- 查看终端错误信息
# 重新安装 Streamlit
pip install streamlit --upgrade
# 使用其他端口
streamlit run streamlit_app.py --server.port 8502
Q6: 内存不足？
A: 优化方案：
- 减小批次大小
- 清空历史记录
- 重启应用
- 关闭其他程序
Q7: CUDA 错误？
A: 如果遇到 CUDA 相关错误：
- 使用 CPU 模式：在训练时设置
device='cpu' - 更新 CUDA 驱动
- 重新安装 PyTorch
# 安装 CPU 版本的 PyTorch
pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
12.6 最佳实践
图片拍摄建议：
- ✅ 使用白色或浅色背景
- ✅ 保持光线充足均匀
- ✅ 避免强烈阴影
- ✅ 保持种子清晰可见
- ✅ 避免种子大量重叠
- ✅ 图片分辨率 > 640×640
系统使用建议：
- 📊 定期查看模型分析，了解识别情况
- 💾 定期备份历史记录
- 🔄 定期清理旧数据，保持系统性能
- ⚙️ 根据实际需求调整置信度阈值
- 📥 重要结果及时导出保存
性能优化建议：
- 使用 GPU 加速训练和推理
- 批量处理时使用合适的批次大小
- 定期清理缓存和临时文件
- 关闭不必要的后台程序
12.7 技术支持
获取帮助：
- 查看项目文档：
README.md,使用说明.md - 运行系统测试：
python test_system.py - 查看日志文件：检查错误信息
- 搜索常见问题：查看 FAQ 部分
反馈问题：
- 描述问题现象
- 提供错误信息
- 说明操作步骤
- 附上截图（如果可能）
总结
本项目实现了一个完整的基于 YOLOv8 的农作物种子识别系统，包含以下核心功能：
主要成果
-
算法实现
- ✅ 完整的数据预处理流程
- ✅ YOLOv8 模型训练与优化
- ✅ 模型评估与性能分析
- ✅ 达到 94.5% 的 mAP50 精度
-
系统功能
- ✅ 单张图片识别
- ✅ 批量图片处理
- ✅ 历史记录管理
- ✅ 模型性能分析
- ✅ 系统配置管理
-
技术特点
- ✅ 友好的 Web 界面
- ✅ 实时数据可视化
- ✅ 完整的数据持久化
- ✅ 高效的批量处理
- ✅ 详细的统计分析
-
文档完善
- ✅ 详细的技术文档
- ✅ 完整的使用说明
- ✅ 丰富的代码注释
- ✅ 清晰的项目结构
应用价值
本系统可应用于：
- 🌾 农业生产中的种子分类
- 🔬 粮食品质检测
- 🏭 智能分选系统
- 📚 农业教学与科研
- 💼 种子贸易与管理
未来展望
系统可进一步扩展：
- 📱 移动端应用开发
- 🎥 实时视频流检测
- 🤖 自动化分选机器人集成
- 🌐 云端部署与 API 服务
- 📊 更多数据分析功能
- 🔍 种子质量评估
- 🌱 病虫害检测
项目信息：
- 项目名称：基于 YOLOv8 的农作物种子种类识别系统
- 版本：v1.0.0
- 开发时间：2026年
- 技术栈：YOLOv8, Streamlit, PyTorch, OpenCV, Plotly
- 支持类别：9种印度食用油料作物种子
- 模型精度：mAP50 = 94.5%
致谢：
- Ultralytics 团队提供的 YOLOv8 框架
- Streamlit 团队提供的 Web 框架
- Indian Edible Oil Seed Dataset 数据集提供者
- 开源社区的支持与贡献
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
7
0- 0
已为社区贡献10条内容
所有评论(0)