在木材加工行业，传统的人工缺陷检测方法准确率普遍低于70%，而人为错误导致的资源浪费高达22%。面对这一行业痛点，深度学习技术正在彻底改变木材质量控制的游戏规则。YOLOv8作为当前最先进的目标检测算法之一，在木材缺陷识别领域展现出了惊人的潜力。

本文将带你从零开始构建一个完整的YOLOv8木材缺陷识别检测系统，涵盖环境配置、数据集处理、模型训练、性能优化到实际部署的全流程。无论你是深度学习初学者还是有一定经验的开发者，都能通过本文学会如何将前沿的AI技术应用到实际的工业检测场景中。

1. 木材缺陷检测的技术挑战与解决方案

1.1 传统检测方法的局限性

木材缺陷检测长期以来依赖人工目视检查，这种方法存在明显缺陷：检测人员容易疲劳，主观判断差异大，且检测速度无法满足现代化生产线的需求。研究表明，人工检测的准确率通常低于70%，而在连续工作环境下，误检率和漏检率会进一步上升。

传统机器视觉方法虽然在一定程度上实现了自动化，但对光照条件、木材纹理变化等因素敏感，泛化能力有限。超声波、X射线等物理检测方法则存在设备成本高、操作复杂、有安全风险等问题。

1.2 YOLOv8的技术优势

YOLOv8（You Only Look Once version 8）作为单阶段目标检测算法的代表，在精度和速度之间取得了良好平衡。其核心优势包括：

• 实时性：单次前向传播即可完成检测，推理速度快
• 高精度：采用先进的骨干网络和特征金字塔结构
• 易于部署：支持ONNX格式导出，兼容多种推理引擎
• 灵活性：提供n/s/m/l/x多种尺寸的预训练模型

根据最新研究，基于YOLOv8改进的木材缺陷检测模型在mAP50指标上可达93.8%，相比原始模型提升6.8%，同时参数量减少16.2%，真正实现了精度与效率的双重优化。

2. 环境配置与依赖安装

2.1 系统要求与Python环境

推荐使用以下环境配置：

• 操作系统：Ubuntu 20.04+ / Windows 10+
• Python版本：3.8-3.10
• CUDA：11.3+（GPU训练必需）
• 内存：16GB+（建议32GB用于大型数据集）
• 存储：100GB+可用空间

2.2 创建虚拟环境与依赖安装

# 创建并激活虚拟环境 conda create -n yolov8-wood-defect python=3.9 conda activate yolov8-wood-defect # 安装PyTorch（根据CUDA版本选择） pip install torch==1.13.1+cu116 torchvision==0.14.1+cu116 torchaudio==0.13.1 --extra-index-url https://download.pytorch.org/whl/cu116 # 安装Ultralytics YOLOv8 pip install ultralytics # 安装其他依赖 pip install opencv-python pillow matplotlib seaborn pandas numpy scikit-learn albumentations

2.3 验证安装结果

创建验证脚本verify_installation.py：

import torch import ultralytics import cv2 import numpy as np print(f"PyTorch版本: {torch.__version__}") print(f"CUDA可用: {torch.cuda.is_available()}") print(f"CUDA版本: {torch.version.cuda}") print(f"Ultralytics版本: {ultralytics.__version__}") # 测试GPU if torch.cuda.is_available(): device = torch.device('cuda') print(f"当前GPU: {torch.cuda.get_device_name(0)}") else: device = torch.device('cpu') print("使用CPU进行训练") # 测试OpenCV print(f"OpenCV版本: {cv2.__version__}") print("环境配置验证完成！")

3. 数据集准备与预处理

3.1 木材缺陷数据集介绍

木材缺陷通常包括以下几类：

• 活结（Live Knot）：与周围木材紧密结合的节疤
• 死结（Dead Knot）：容易脱落的节疤
• 裂缝（Crack）：木材表面的开裂
• 树脂囊（Resin Pocket）：含有树脂的空洞
• 树髓（Pith）：木材中心部位的松软组织
• 带裂缝的节疤：复杂缺陷组合

3.2 数据标注格式

YOLOv8使用YOLO格式的标注文件，每个图像对应一个.txt文件，格式如下：

<class_id> <x_center> <y_center> <width> <height>

示例标注文件内容：

0 0.45 0.32 0.15 0.12 1 0.67 0.54 0.08 0.09

3.3 数据集目录结构

创建标准的YOLOv8数据集目录结构：

wood_defect_dataset/ ├── images/ │ ├── train/ │ ├── val/ │ └── test/ ├── labels/ │ ├── train/ │ ├── val/ │ └── test/ └── dataset.yaml

3.4 数据集配置文件

创建dataset.yaml配置文件：

# 数据集路径 path: /path/to/wood_defect_dataset train: images/train val: images/val test: images/test # 类别数量 nc: 6 # 类别名称 names: 0: live_knot 1: dead_knot 2: crack 3: resin_pocket 4: pith 5: cracked_knot # 下载地址/自动下载设置 download: null

3.5 数据增强策略

为了提高模型泛化能力，需要实施有效的数据增强：

import albumentations as A from albumentations.pytorch import ToTensorV2 def get_train_transforms(image_size=640): return A.Compose([ A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.RandomBrightnessContrast(p=0.2), A.HueSaturationValue(p=0.2), A.GaussianBlur(blur_limit=3, p=0.1), A.MotionBlur(blur_limit=3, p=0.1), A.RandomGamma(p=0.2), A.CLAHE(p=0.2), A.Resize(image_size, image_size), A.Normalize(mean=[0, 0, 0], std=[1, 1, 1]), ToTensorV2() ], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels'])) def get_val_transforms(image_size=640): return A.Compose([ A.Resize(image_size, image_size), A.Normalize(mean=[0, 0, 0], std=[1, 1, 1]), ToTensorV2() ], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))

4. YOLOv8模型训练与优化

4.1 基础模型训练

使用YOLOv8进行模型训练的基本代码：

from ultralytics import YOLO import os # 加载预训练模型 model = YOLO('yolov8n.pt') # 可以选择yolov8s.pt, yolov8m.pt等 # 训练配置 training_config = { 'data': 'dataset.yaml', 'epochs': 100, 'imgsz': 640, 'batch': 16, 'device': 0, # 使用GPU，如果是CPU则设置为'cpu' 'workers': 8, 'optimizer': 'auto', 'lr0': 0.01, # 初始学习率 'lrf': 0.01, # 最终学习率 'momentum': 0.937, 'weight_decay': 0.0005, 'warmup_epochs': 3.0, 'warmup_momentum': 0.8, 'box': 7.5, # 框损失权重 'cls': 0.5, # 分类损失权重 'dfl': 1.5, # DFL损失权重 'save_period': 10, # 每10个epoch保存一次 'seed': 42, 'deterministic': True } # 开始训练 results = model.train(**training_config) print("训练完成！")

4.2 高级训练配置

对于木材缺陷检测这种特定任务，可以进行更精细的配置：

# 高级训练配置 advanced_config = { 'data': 'dataset.yaml', 'epochs': 150, 'patience': 50, # 早停耐心值 'imgsz': 640, 'batch': 16, 'device': 0, 'workers': 8, 'optimizer': 'AdamW', 'lr0': 0.001, 'lrf': 0.01, 'momentum': 0.9, 'weight_decay': 0.05, 'warmup_epochs': 5.0, 'warmup_momentum': 0.8, 'box': 7.5, 'cls': 0.5, 'dfl': 1.5, 'close_mosaic': 10, # 最后10个epoch关闭Mosaic增强 'overlap_mask': True, 'mask_ratio': 4, 'dropout': 0.1, # 添加dropout防止过拟合 'val': True, # 开启验证 'save_json': True, # 保存JSON格式的结果 'single_cls': False, # 多类别检测 'augment': True, # 开启数据增强 'rect': False, # 矩形训练 'cos_lr': True, # 余弦学习率调度 'label_smoothing': 0.1, # 标签平滑 'nbs': 64, # 名义批量大小 } # 使用自定义模型结构（如果需要） class CustomYOLO(YOLO): def __init__(self, model='yolov8n.pt'): super().__init__(model) def customize_model(self): # 可以在这里添加自定义层或修改模型结构 pass # 实例化并训练 custom_model = CustomYOLO('yolov8n.pt') results = custom_model.train(**advanced_config)

4.3 模型评估与指标分析

训练完成后，需要对模型进行全面的评估：

from ultralytics import YOLO import matplotlib.pyplot as plt import seaborn as sns from sklearn.metrics import confusion_matrix, classification_report import numpy as np # 加载最佳模型 model = YOLO('runs/detect/train/weights/best.pt') # 在验证集上评估 metrics = model.val( data='dataset.yaml', imgsz=640, batch=16, conf=0.25, # 置信度阈值 iou=0.45, # IoU阈值 device=0, split='val' ) # 打印关键指标 print(f"mAP50: {metrics.box.map50:.4f}") print(f"mAP50-95: {metrics.box.map:.4f}") print(f"精确率: {metrics.box.precision:.4f}") print(f"召回率: {metrics.box.recall:.4f}") # 绘制混淆矩阵 def plot_confusion_matrix(cm, classes, title='Confusion Matrix'): plt.figure(figsize=(10, 8)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=classes, yticklabels=classes) plt.title(title) plt.ylabel('True Label') plt.xlabel('Predicted Label') plt.tight_layout() plt.savefig('confusion_matrix.png', dpi=300, bbox_inches='tight') plt.show() # 如果需要更详细的类别分析 class_names = ['live_knot', 'dead_knot', 'crack', 'resin_pocket', 'pith', 'cracked_knot'] # 可以进一步分析每个类别的性能 for i, class_name in enumerate(class_names): print(f"{class_name}: AP50 = {metrics.box.ap50[i]:.4f}, AP50-95 = {metrics.box.ap[i]:.4f}")

5. 模型改进与优化策略

5.1 基于DFT-YOLO的改进方案

根据最新研究，我们可以借鉴DFT-YOLO的改进思路来优化我们的模型：

import torch import torch.nn as nn from ultralytics.nn.modules import Conv, C2f, Detect # 膨胀感知残差模块（DWR） class DWRModule(nn.Module): def __init__(self, c1, c2, dilation_rates=[1, 3, 5]): super().__init__() self.convs = nn.ModuleList() for dilation in dilation_rates: self.convs.append(Conv(c1, c2, k=3, s=1, p=dilation, d=dilation, act=True)) self.fusion = Conv(c2 * len(dilation_rates), c2, k=1, s=1, act=True) def forward(self, x): outputs = [conv(x) for conv in self.convs] return self.fusion(torch.cat(outputs, dim=1)) # 改进的C2f模块（C2f-DWR） class C2f_DWR(nn.Module): def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5): super().__init__() self.c = int(c2 * e) self.cv1 = Conv(c1, 2 * self.c, 1, 1) self.cv2 = Conv((2 + n) * self.c, c2, 1) self.m = nn.ModuleList(DWRModule(self.c, self.c) for _ in range(n)) def forward(self, x): y = list(self.cv1(x).chunk(2, 1)) y.extend(m(y[-1]) for m in self.m) return self.cv2(torch.cat(y, 1)) # 自定义YOLOv8模型 class CustomYOLOv8(nn.Module): def __init__(self, nc=80): super().__init__() # 这里可以替换原有的C2f模块为C2f_DWR # 具体实现需要根据YOLOv8的完整结构进行调整 pass

5.2 注意力机制集成

集成CBAM（Convolutional Block Attention Module）注意力机制：

class CBAM(nn.Module): def __init__(self, channels, reduction=16): super().__init__() # 通道注意力 self.channel_attention = nn.Sequential( nn.AdaptiveAvgPool2d(1), nn.Conv2d(channels, channels // reduction, 1), nn.ReLU(), nn.Conv2d(channels // reduction, channels, 1), nn.Sigmoid() ) # 空间注意力 self.spatial_attention = nn.Sequential( nn.Conv2d(2, 1, 7, padding=3), nn.Sigmoid() ) def forward(self, x): # 通道注意力 ca = self.channel_attention(x) x = x * ca # 空间注意力 avg_out = torch.mean(x, dim=1, keepdim=True) max_out, _ = torch.max(x, dim=1, keepdim=True) sa_input = torch.cat([avg_out, max_out], dim=1) sa = self.spatial_attention(sa_input) x = x * sa return x # 集成CBAM的卷积模块 class Conv_CBAM(nn.Module): def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): super().__init__() self.conv = Conv(c1, c2, k, s, p, g, act) self.cbam = CBAM(c2) def forward(self, x): return self.cbam(self.conv(x))

6. 模型部署与推理优化

6.1 模型导出为ONNX格式

from ultralytics import YOLO # 加载训练好的模型 model = YOLO('runs/detect/train/weights/best.pt') # 导出为ONNX格式 success = model.export( format='onnx', imgsz=640, dynamic=True, # 动态批量大小 simplify=True, # 简化模型 opset=12, # ONNX算子集版本 workspace=4 # GPU内存限制（GB） ) if success: print("模型导出成功！") else: print("模型导出失败！")

6.2 使用OpenVINO进行推理优化

from openvino.runtime import Core import cv2 import numpy as np class OpenVINOInference: def __init__(self, model_path): self.core = Core() self.model = self.core.read_model(model_path) self.compiled_model = self.core.compile_model(self.model, "CPU") self.input_layer = self.compiled_model.input(0) self.output_layer = self.compiled_model.output(0) def preprocess(self, image): # 图像预处理 image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image = cv2.resize(image, (640, 640)) image = image.transpose(2, 0, 1) # HWC to CHW image = image.astype(np.float32) / 255.0 image = np.expand_dims(image, 0) # 添加批次维度 return image def postprocess(self, outputs, orig_shape, conf_threshold=0.25, iou_threshold=0.45): # 后处理：非极大值抑制等 # 这里需要根据YOLOv8的输出格式进行解析 pass def inference(self, image): input_tensor = self.preprocess(image) outputs = self.compiled_model([input_tensor])[self.output_layer] return self.postprocess(outputs, image.shape)

6.3 TensorRT加速推理

import tensorrt as trt import pycuda.driver as cuda import pycuda.autoinit class TensorRTInference: def __init__(self, engine_path): self.logger = trt.Logger(trt.Logger.WARNING) with open(engine_path, "rb") as f, trt.Runtime(self.logger) as runtime: self.engine = runtime.deserialize_cuda_engine(f.read()) self.context = self.engine.create_execution_context() self.stream = cuda.Stream() # 分配输入输出内存 self.allocate_buffers() def allocate_buffers(self): # 分配GPU内存 pass def inference(self, image): # 执行推理 pass

7. 图形用户界面开发

7.1 使用Gradio构建Web界面

import gradio as gr import cv2 import numpy as np from ultralytics import YOLO import tempfile import os class WoodDefectDetector: def __init__(self, model_path): self.model = YOLO(model_path) self.class_names = ['live_knot', 'dead_knot', 'crack', 'resin_pocket', 'pith', 'cracked_knot'] def predict(self, image, conf_threshold=0.25): # 执行预测 results = self.model(image, conf=conf_threshold) # 绘制检测结果 result_image = results[0].plot() result_image = cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB) # 统计检测结果 detection_info = [] for box in results[0].boxes: class_id = int(box.cls) confidence = float(box.conf) detection_info.append({ 'class': self.class_names[class_id], 'confidence': confidence, 'bbox': box.xywh[0].tolist() }) return result_image, detection_info # 创建检测器实例 detector = WoodDefectDetector('runs/detect/train/weights/best.pt') def process_image(input_image, conf_threshold): # 处理上传的图像 if input_image is None: return None, "请上传图像" image = cv2.cvtColor(np.array(input_image), cv2.COLOR_RGB2BGR) result_image, detection_info = detector.predict(image, conf_threshold) # 格式化检测信息 info_text = f"检测到 {len(detection_info)} 个缺陷：\n" for i, detection in enumerate(detection_info): info_text += f"{i+1}. {detection['class']}: {detection['confidence']:.3f}\n" return result_image, info_text # 创建Gradio界面 with gr.Blocks(title="木材缺陷检测系统") as demo: gr.Markdown("# 🪵 木材缺陷智能检测系统") gr.Markdown("上传木材图像，系统将自动检测并分类各种缺陷") with gr.Row(): with gr.Column(): image_input = gr.Image(label="上传木材图像", type="pil") confidence_slider = gr.Slider(0.1, 0.9, value=0.25, label="置信度阈值") submit_btn = gr.Button("开始检测", variant="primary") with gr.Column(): image_output = gr.Image(label="检测结果") text_output = gr.Textbox(label="检测信息", lines=10) submit_btn.click( fn=process_image, inputs=[image_input, confidence_slider], outputs=[image_output, text_output] ) # 示例图像 gr.Examples( examples=["example1.jpg", "example2.jpg", "example3.jpg"], inputs=image_input, label="点击查看示例" ) if __name__ == "__main__": demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

7.2 桌面应用程序开发

使用PyQt5开发桌面应用程序：

import sys from PyQt5.QtWidgets import (QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QPushButton, QLabel, QSlider, QTextEdit, QFileDialog, QWidget, QProgressBar) from PyQt5.QtCore import Qt, QThread, pyqtSignal from PyQt5.QtGui import QPixmap, QImage import cv2 from ultralytics import YOLO class DetectionThread(QThread): finished = pyqtSignal(object, object) def __init__(self, image_path, model_path, conf_threshold): super().__init__() self.image_path = image_path self.model_path = model_path self.conf_threshold = conf_threshold def run(self): model = YOLO(self.model_path) image = cv2.imread(self.image_path) results = model(image, conf=self.conf_threshold) result_image = results[0].plot() result_image = cv2.cvtColor(result_image, cv2.COLOR_BGR2RGB) self.finished.emit(result_image, results[0]) class MainWindow(QMainWindow): def __init__(self): super().__init__() self.initUI() self.model = YOLO('runs/detect/train/weights/best.pt') def initUI(self): self.setWindowTitle('木材缺陷检测系统') self.setGeometry(100, 100, 1200, 800) # 创建中心部件 central_widget = QWidget() self.setCentralWidget(central_widget) # 主布局 layout = QHBoxLayout() # 左侧控制面板 control_panel = QVBoxLayout() self.open_btn = QPushButton('打开图像') self.open_btn.clicked.connect(self.open_image) self.detect_btn = QPushButton('开始检测') self.detect_btn.clicked.connect(self.detect_defects) self.detect_btn.setEnabled(False) self.conf_label = QLabel('置信度阈值: 0.25') self.conf_slider = QSlider(Qt.Horizontal) self.conf_slider.setRange(10, 90) self.conf_slider.setValue(25) self.conf_slider.valueChanged.connect(self.update_conf_label) self.progress_bar = QProgressBar() self.progress_bar.setVisible(False) control_panel.addWidget(self.open_btn) control_panel.addWidget(self.detect_btn) control_panel.addWidget(self.conf_label) control_panel.addWidget(self.conf_slider) control_panel.addWidget(self.progress_bar) control_panel.addStretch() # 右侧显示区域 display_panel = QVBoxLayout() self.image_label = QLabel() self.image_label.setAlignment(Qt.AlignCenter) self.image_label.setMinimumSize(640, 480) self.result_text = QTextEdit() self.result_text.setReadOnly(True) display_panel.addWidget(self.image_label) display_panel.addWidget(QLabel('检测结果:')) display_panel.addWidget(self.result_text) layout.addLayout(control_panel, 1) layout.addLayout(display_panel, 2) central_widget.setLayout(layout) def open_image(self): file_path, _ = QFileDialog.getOpenFileName( self, '打开木材图像', '', '图像文件 (*.jpg *.jpeg *.png *.bmp)' ) if file_path: self.current_image_path = file_path pixmap = QPixmap(file_path) self.image_label.setPixmap( pixmap.scaled(640, 480, Qt.KeepAspectRatio, Qt.SmoothTransformation) ) self.detect_btn.setEnabled(True) def update_conf_label(self, value): self.conf_label.setText(f'置信度阈值: {value/100:.2f}') def detect_defects(self): if hasattr(self, 'current_image_path'): self.progress_bar.setVisible(True) self.detect_btn.setEnabled(False) self.thread = DetectionThread( self.current_image_path, 'runs/detect/train/weights/best.pt', self.conf_slider.value() / 100 ) self.thread.finished.connect(self.on_detection_finished) self.thread.start() def on_detection_finished(self, result_image, results): # 显示结果图像 height, width, channel = result_image.shape bytes_per_line = 3 * width q_img = QImage(result_image.data, width, height, bytes_per_line, QImage.Format_RGB888) self.image_label.setPixmap(QPixmap.fromImage(q_img)) # 显示检测信息 info_text = f"检测到 {len(results.boxes)} 个缺陷：\n\n" for i, box in enumerate(results.boxes): class_id = int(box.cls) confidence = float(box.conf) class_name = self.model.names[class_id] info_text += f"{i+1}. {class_name}: {confidence:.3f}\n" self.result_text.setText(info_text) self.progress_bar.setVisible(False) self.detect_btn.setEnabled(True) def main(): app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(app.exec_()) if __name__ == '__main__': main()

8. 性能优化与生产部署

8.1 模型量化与加速

import torch from ultralytics import YOLO def quantize_model(model_path, save_path): """量化模型以减少大小并提高推理速度""" model = YOLO(model_path) # 动态量化 quantized_model = torch.quantization.quantize_dynamic( model.model, {torch.nn.Linear, torch.nn.Conv2d}, dtype=torch.qint8 ) # 保存量化模型 torch.save(quantized_model.state_dict(), save_path) print(f"量化模型已保存到: {save_path}") # 使用示例 quantize_model('runs/detect/train/weights/best.pt', 'quantized_wood_defect_model.pth')

8.2 批量处理优化

import os from pathlib import Path from ultralytics import YOLO import cv2 import time class BatchProcessor: def __init__(self, model_path, batch_size=8): self.model = YOLO(model_path) self.batch_size = batch_size def process_folder(self, input_folder, output_folder, conf_threshold=0.25): """批量处理文件夹中的图像""" input_path = Path(input_folder) output_path = Path(output_folder) output_path.mkdir(parents=True, exist_ok=True) image_files = list(input_path.glob('*.jpg')) + list(input_path.glob('*.png')) total_files = len(image_files) print(f"找到 {total_files} 个图像文件") results = [] for i in range(0, total_files, self.batch_size): batch_files = image_files[i:i + self.batch_size] batch_images = [] for file_path in batch_files: image = cv2.imread(str(file_path)) if image is not None: batch_images.append(image) if batch_images: # 批量推理 batch_results = self.model(batch_images, conf=conf_threshold, verbose=False) for j, result in enumerate(batch_results): if j < len(batch_files): # 保存结果图像 output_file = output_path / f"result_{batch_files[j].stem}.jpg" result_image = result.plot() cv2.imwrite(str(output_file), result_image) # 记录结果 detection_count = len(result.boxes) results.append({ 'file': batch_files[j].name, 'detections': detection_count, 'output_path': str(output_file) }) progress = min(i + self.batch_size, total_files) print(f"处理进度: {progress}/{total_files} ({progress/total_files*100:.1f}%)") return results # 使用示例 processor = BatchProcessor('runs/detect/train/weights/best.pt') results = processor.process_folder('input_images', 'output_results')

8.3 监控与日志系统

import logging import json from datetime import datetime import psutil import GPUtil class MonitoringSystem: def __init__(self, log_file='detection_log.json'): self.log_file = log_file self.setup_logging() def setup_logging(self): logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('detection_system.log'), logging.StreamHandler() ] ) def log_detection(self, image_path, results, processing_time): """记录检测结果""" log_entry = { 'timestamp': datetime.now().isoformat(), 'image_path': image_path, 'detection_count': len(results.boxes), 'processing_time': processing_time, 'system_resources': self.get_system_resources(), 'detailed_results': [ { 'class': results.names[int(box.cls)], 'confidence': float(box.conf), 'bbox': box.xywh[0].tolist() } for box in results.boxes ] } with open(self.log_file, 'a') as f: f.write(json.dumps(log_entry) + '\n') logging.info(f"检测完成: {image_path} - 发现 {len(results.boxes)} 个缺陷") def get_system_resources(self): """获取系统资源使用情况""" return { 'cpu_percent': psutil.cpu_percent(), 'memory_percent': psutil.virtual_memory().percent, 'gpu_usage': self.get_gpu_usage() } def get_gpu_usage(self): """获取GPU使用情况""" try: gpus = GPUtil.getGPUs() return [{'id': gpu.id, 'load': gpu.load, 'memory': gpu.memoryUsed} for gpu in gpus] except: return [] # 集成监控系统 monitor = MonitoringSystem()

9. 实际应用案例与性能评估

9.1 不同木材类型的检测效果

在实际应用中，我们对多种木材类型进行了测试：

9.2 性能基准测试

在不同硬件环境下的推理速度测试：

9.3 与传统方法对比

与传统检测方法的性能对比：