• （4）paddle---PCB检测的例子

    1、主要参考

    （1）大佬教程

    基于PaddleDetection的PCB瑕疵检测_AI Studio的博客-CSDN博客

    （2）blibli视频

    253-14_PCB电路板缺陷检测_项目配置文件_dec_哔哩哔哩_bilibili

    （3）coco数据集说明

    『深度应用』目标检测coco数据集格式介绍 - 腾讯云开发者社区-腾讯云

    2、模型的下载

    （1）下载地址

    北京大学智能机器人开放实验室

     印刷电路板（PCB）瑕疵数据集。它是一个公共合成PCB数据集，包含1386张图像，具有6种缺陷（漏孔、鼠咬、开路、短路、杂散、杂铜），用于图像检测、分类和配准任务

    看了一下，上面地址下载的数据集，是voc格式的

    （2）根据百度教程来的话可以通过AIstudio直接下载

    3、模型的特征查看

    （1）查看各个缺陷的分布情况（类别数是否均匀，如果不均匀可以考虑调整loss的计算方法）

    （2）查看锚框的长宽比，看看都是什么形状的

    （3）看看锚框的大小（和原图大小的比值，看看是不是都是小物体）

    （4）文件pcb_dataset_analysis.py如下

    1. import json
    2. from collections import defaultdict
    3. import matplotlib.pyplot as plt
    4. %matplotlib inline
    5.  
    6. with open("/home/aistudio/work/PCB_DATASET/Annotations/train.json") as f:
    7.     data = json.load(f)
    8.  
    9. imgs = {}
    10. for img in data['images']:
    11.     imgs[img['id']] = {
    12.         'h': img['height'],
    13.         'w': img['width'],
    14.         'area': img['height'] * img['width'],
    15.     }
    16.  
    17. hw_ratios = []
    18. area_ratios = []
    19. label_count = defaultdict(int)
    20. for anno in data['annotations']:
    21.     hw_ratios.append(anno['bbox'][3]/anno['bbox'][2])
    22.     area_ratios.append(anno['area']/imgs[anno['image_id']]['area'])
    23.     label_count[anno['category_id']] += 1
    24.  
    25. #查看各个缺陷的分布情况（类别数是否均匀，如果不均匀可以考虑调整loss的计算方法）
    26. print( label_count, len(data['annotations']) / len(data['images']) )
    27.  
    28. #查看锚框的长宽比，看看都是什么形状的
    29. plt.hist(hw_ratios, bins=100, range=[0, 2])
    30. plt.show()
    31.  
    32. #看看锚框的大小（和原图大小的比值，看看是不是都是小物体）
    33. plt.hist(area_ratios, bins=100, range=[0, 0.005])
    34. plt.show()

    1)各个缺陷的分布和每张图的缺陷数如下

    #查看各个缺陷的分布情况（类别数是否均匀，如果不均匀可以考虑调整loss的计算方法）
    print( label_count, len(data['annotations']) / len(data['images']) )

     2）长宽比的分布如下

    #查看锚框的长宽比，看看都是什么形状的
    plt.hist(hw_ratios, bins=100, range=[0, 2])
    plt.show()

     3）锚框和图的面积比如下

    #看看锚框的大小（和原图大小的比值，看看是不是都是小物体）
    plt.hist(area_ratios, bins=100, range=[0, 0.005])
    plt.show()

    4、下载paddle的object项目

    4.1 下载

    (1)paddle官网

    飞桨PaddlePaddle-源于产业实践的开源深度学习平台

    （2）下载指定PaddleDetection

     (3)对应的github地址如下

    https://github.com/PaddlePaddle/PaddleDetection

    4.2安装相关环境

    1. #（1）在对应目录下
    2. conda activate chenpaddle_cp310
    3.  
    4. #（2）安装相关环境
    5. pip install -r requirements.txt 
    6.  
    7. pip install pycocotools

    5、基于faster-rcnn的PCB缺陷检测

    （1）一下参考来自官网

    基于PaddleDetection的PCB瑕疵检测-FasterRCNN - 飞桨AI Studio

    （2）配置参数

    在检测目录下创建chenfastrcnn 目录，然后创建文件pcb_faster_rcnn_r50_fpn_3x_coco.yml内容如下 

    1. metric: COCO           # Label评价指标，coco IoU:0.5:0.95
    2. num_classes: 7         # 类别数量，coco类别比实际类别（voc类别）+1
    3.  
    4. TrainDataset:
    5.   !COCODataSet
    6.     image_dir: images
    7.     anno_path: Annotations/train.json
    8.     dataset_dir: /home/chen/deep_data/pcb/PCB_DATASET_AI_STUDIO/PCB_DATASET
    9.     data_fields: ['image', 'gt_bbox', 'gt_class']#, 'is_crowd'
    10.  
    11. EvalDataset:
    12.   !COCODataSet
    13.     image_dir: images
    14.     anno_path: Annotations/val.json
    15.     dataset_dir: /home/chen/deep_data/pcb/PCB_DATASET_AI_STUDIO/PCB_DATASET
    16.  
    17. TestDataset:
    18.   !ImageFolder
    19.     anno_path: Annotations/val.json
    20.  
    21.  
    22. use_gpu: true                          # 根据硬件选择是否使用GPU 
    23. log_iter: 10                           # 日志窗口的尺度
    24. save_dir: output/     # 模型输出文件夹
    25. snapshot_epoch: 1                      # 生成快照的频率，即每1个周期生成一次
    26.  
    27. epoch: 24                      ### 训练周期：24
    28.  
    29. LearningRate:                  ### 学习率：阶段学习率
    30.   base_lr: 0.0025              # 起始学习率:0.0025 
    31.   schedulers:
    32.   - !PiecewiseDecay            ## 阶段学习率
    33.     gamma: 0.1                 # 每次学习率变化为原来的1/10
    34.     milestones: [16, 22]       # 总共进行两次学习率的降低
    35.   - !LinearWarmup              ## 慢启动，共执行200次迭代，学习率为初始学习率的0.1
    36.     start_factor: 0.1
    37.     steps: 200
    38.  
    39. OptimizerBuilder:              ### 优化方法：基于动量的SGD
    40.   optimizer:
    41.     momentum: 0.9
    42.     type: Momentum
    43.   regularizer:
    44.     factor: 0.0001
    45.     type: L2
    46.  
    47. architecture: FasterRCNN                   # 总框架类型
    48. # 预训练模型
    49. pretrain_weights: https://paddledet.bj.bcebos.com/models/pretrained/ResNet50_cos_pretrained.pdparams
    50.  
    51. ## 检测模型的体系结构，包含骨干、支路、区域建议、BBox头和BBox头后处理
    52. FasterRCNN:
    53.   backbone: ResNet                        # 主干网络：ResNet
    54.   neck: FPN                               # 特征金字塔网络
    55.   rpn_head: RPNHead                       # 区域建议头：基于FPN的RPNHead
    56.   bbox_head: BBoxHead                     # BBox头：BBoxHead
    57.   # post process   
    58.   bbox_post_process: BBoxPostProcess      # BBox后处理器
    59.  
    60. ResNet:
    61.   # index 0 stands for res2
    62.   depth: 50                               # 深度50，即ResNet50
    63.   norm_type: bn                           # 正则化类型BN，基本上是唯一选择
    64.   freeze_at: 0                            # 冻结部分，ResNet的前两层
    65.   return_idx: [0,1,2,3]                   # 提取特征的位置，即用于FPN的特征，其实index为0
    66.   num_stages: 4
    67.  
    68. FPN:
    69.   out_channel: 256                        # FPN通道数：256
    70.  
    71. RPNHead:
    72.   anchor_generator:                                    ## Anchor生成器
    73.     aspect_ratios: [0.5, 1.0, 2.0]                     # Anchor的比例1:2,1:1,2:1
    74.     anchor_sizes: [[32], [64], [128], [256], [512]]    # Anchor的尺度
    75.     strides: [4, 8, 16, 32, 64]                        # Anchor的步长
    76.   rpn_target_assign:                                   ## RPN设置
    77.     batch_size_per_im: 256                             # RPN采样数量: 256 
    78.     fg_fraction: 0.5                                   # 正样本数量: 256*0.5=128   
    79.     negative_overlap: 0.3                              # 负样本IoU<0.3 
    80.     positive_overlap: 0.7                              # 正阳IoU>0.7
    81.     use_random: True
    82.   train_proposal:                                      ## 训练建议框设置
    83.     min_size: 0.0                                      
    84.     nms_thresh: 0.7                                    # 训练阶段nms阈值
    85.     pre_nms_top_n: 2000                                # 第一阶段nms数量
    86.     post_nms_top_n: 1000                               # 第二阶段nms数量
    87.     topk_after_collect: True
    88.   test_proposal:                                       ## 测试建议框设置
    89.     min_size: 0.0
    90.     nms_thresh: 0.7                                    # 测试阶段nms阈值     
    91.     pre_nms_top_n: 1000                                # 第一阶段nms数量
    92.     post_nms_top_n: 1000                               # 第二阶段nms数量
    93.  
    94. BBoxHead:                                              ## BBox头
    95.   head: TwoFCHead                                      # 两个FC头
    96.   roi_extractor:
    97.     resolution: 7                                      # RoIPooling特征层的尺度7×7
    98.     sampling_ratio: 0
    99.     aligned: True                                      # 启用RoIAlign
    100.   bbox_assigner: BBoxAssigner
    101.  
    102. BBoxAssigner:
    103.   batch_size_per_im: 512                               # batch数量：512
    104.   bg_thresh: 0.5                                       # 背景阈值<0.5
    105.   fg_thresh: 0.5                                       # 前景阈值>0.5
    106.   fg_fraction: 0.25
    107.   use_random: True
    108.  
    109. TwoFCHead:
    110.   out_channel: 1024                                    # 全连接层特征维度（后面紧跟分类和回归层）：1024
    111.  
    112.  
    113. BBoxPostProcess:
    114.   decode: RCNNBox
    115.   nms:
    116.     name: MultiClassNMS
    117.     keep_top_k: 100
    118.     score_threshold: 0.05
    119.     nms_threshold: 0.5
    120.  
    121. worker_num: 2
    122.  
    123.  
    124. TrainReader:
    125.   sample_transforms:  # 数据预处理
    126.   - Decode: {}
    127.   - RandomResize: {target_size: [[640, 1333], [672, 1333], [704, 1333], [736, 1333], [768, 1333], [800, 1333]], interp: 2, keep_ratio: True}
    128.   - RandomFlip: {prob: 0.5}
    129.   - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
    130.   - Permute: {}
    131.   batch_transforms:   
    132.   - PadBatch: {pad_to_stride: 32}
    133.   batch_size: 1      # 每批大尺度
    134.   shuffle: true      # 是否随机
    135.   drop_last: true    # 最后一个batch不足batch_sizes时，是否将多余数据进行丢弃
    136.  
    137.  
    138. EvalReader:
    139.   sample_transforms:
    140.   - Decode: {}
    141.   - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
    142.   - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
    143.   - Permute: {}
    144.   batch_transforms:
    145.   - PadBatch: {pad_to_stride: 32}
    146.   batch_size: 1
    147.   shuffle: false
    148.   drop_last: false
    149.   drop_empty: false
    150.  
    151.  
    152. TestReader:
    153.   sample_transforms:
    154.   - Decode: {}
    155.   - Resize: {interp: 2, target_size: [800, 1333], keep_ratio: True}
    156.   - NormalizeImage: {is_scale: true, mean: [0.485,0.456,0.406], std: [0.229, 0.224,0.225]}
    157.   - Permute: {}
    158.   batch_transforms:
    159.   - PadBatch: {pad_to_stride: 32}
    160.   batch_size: 1
    161.   shuffle: false
    162.   drop_last: false

    (2)在PaddleDetection-release-2.5目录下的终端中执行如下命令

    1. CUDA_VISIBLE_DEVICES=0
    2.  
    3.  
    4. python -u tools/train.py -c /home/chen/chen_deep/02PaddleDetection/PaddleDetection-release-2.5/chenfastrcnn/pcb_faster_rcnn_r50_fpn_3x_coco.yml --eval 
    5.  
    6. 或者
    7.  
    8. python -u tools/train.py -c /home/chen/chen_deep/02PaddleDetection/PaddleDetection-release-2.5/chenfastrcnn/pcb_faster_rcnn_r50_fpn_3x_coco.yml --eval -o use_gpu=True
    9.  
    10.  
    11. 或者
    12.  
    13. python -u tools/train.py -c /home/chen/chen_deep/02PaddleDetection/PaddleDetection-release-2.5/chenfastrcnn/pcb_faster_rcnn_r50_fpn_3x_coco.yml --eval -o use_gpu=False

    (3)训练得到的模型在output下面

     （4）测试以下图片，以下命令还有问题，会报错

    python -u tools/infer.py -c /home/chen/chen_deep/02PaddleDetection/PaddleDetection-release-2.5/chenfastrcnn/pcb_faster_rcnn_r50_fpn_3x_coco.yml                 --infer_img=/home/chen/deep_data/pcb/PCB_DATASET_AI_STUDIO/PCB_DATASET/images/04_missing_hole_10.jpg                 -o weights=output/pcb_faster_rcnn_r50_fpn_3x_coco/best_model.pdparams use_gpu=True

     

    6、基于PP-YOLOE+的PCB缺陷检测

    （1）以下引用参考来自paddle官网

    基于PP-YOLOE+的PCB缺陷检测 - 飞桨AI Studio基于PP-YOLOE+实现的PCB缺陷检测方案全流程实战，覆盖训练、调优、部署等 - 飞桨AI Studiohttps://aistudio.baidu.com/aistudio/projectdetail/4670836

    黑盒教程真有意思 ：（

    （2）其中ppyoloe_plus_crn_m_80e_obj365_pretrained_pcb.yml内容如下

    1. _BASE_: [
    2.   './_base_/pcb_detection.yml',
    3.   '../../runtime.yml',
    4.   '../_base_/optimizer_80e.yml',
    5.   '../_base_/ppyoloe_plus_crn.yml',
    6.   '../_base_/ppyoloe_plus_reader.yml',
    7. ]
    8.  
    9. log_iter: 100
    10. snapshot_epoch: 5
    11. weights: output/ppyoloe_plus_crn_m_80e_coco_pretrained_pcb/model_final
    12.  
    13. pretrain_weights: https://bj.bcebos.com/v1/paddledet/models/ppyoloe_plus_crn_m_80e_coco.pdparams
    14. depth_mult: 0.67
    15. width_mult: 0.75

    （3）'./_base_/pcb_detection.yml',文件如下

    1. metric: COCO
    2. num_classes: 6
    3.  
    4. TrainDataset:
    5.   !COCODataSet
    6.     image_dir: images
    7.     anno_path: pcb_cocoanno/train.json
    8.     dataset_dir: dataset/PCB_coco/
    9.     data_fields: ['image', 'gt_bbox', 'gt_class', 'is_crowd']
    10.  
    11. EvalDataset:
    12.   !COCODataSet
    13.     image_dir: images
    14.     anno_path: pcb_cocoanno/val.json
    15.     dataset_dir: dataset/PCB_coco/
    16.  
    17. TestDataset:
    18.   !ImageFolder
    19.     anno_path: pcb_cocoanno/val.json # also support txt (like VOC's label_list.txt)
    20.     dataset_dir: dataset/PCB_coco/ # if set, anno_path will be 'dataset_dir/anno_path'

    （4）'../../runtime.yml',文件内容如下

    1. use_gpu: true
    2. use_xpu: false
    3. log_iter: 20
    4. save_dir: output
    5. snapshot_epoch: 1
    6. print_flops: false
    7.  
    8. # Exporting the model
    9. export:
    10.   post_process: True  # Whether post-processing is included in the network when export model.
    11.   nms: True           # Whether NMS is included in the network when export model.
    12.   benchmark: False    # It is used to testing model performance, if set `True`, post-process and NMS will not be exported.
    13.   fuse_conv_bn: False

    （5） '../_base_/optimizer_80e.yml',内容如下

    1. epoch: 80
    2.  
    3. LearningRate:
    4.   base_lr: 0.001
    5.   schedulers:
    6.     - !CosineDecay
    7.       max_epochs: 96
    8.     - !LinearWarmup
    9.       start_factor: 0.
    10.       epochs: 5
    11.  
    12. OptimizerBuilder:
    13.   optimizer:
    14.     momentum: 0.9
    15.     type: Momentum
    16.   regularizer:
    17.     factor: 0.0005
    18.     type: L2

    (6)ppyoloe_plus_crn.yml

    1. architecture: YOLOv3
    2. norm_type: sync_bn
    3. use_ema: true
    4. ema_decay: 0.9998
    5. ema_black_list: ['proj_conv.weight']
    6. custom_black_list: ['reduce_mean']
    7.  
    8. YOLOv3:
    9.   backbone: CSPResNet
    10.   neck: CustomCSPPAN
    11.   yolo_head: PPYOLOEHead
    12.   post_process: ~
    13.  
    14. CSPResNet:
    15.   layers: [3, 6, 6, 3]
    16.   channels: [64, 128, 256, 512, 1024]
    17.   return_idx: [1, 2, 3]
    18.   use_large_stem: True
    19.   use_alpha: True
    20.  
    21. CustomCSPPAN:
    22.   out_channels: [768, 384, 192]
    23.   stage_num: 1
    24.   block_num: 3
    25.   act: 'swish'
    26.   spp: true
    27.  
    28. PPYOLOEHead:
    29.   fpn_strides: [32, 16, 8]
    30.   grid_cell_scale: 5.0
    31.   grid_cell_offset: 0.5
    32.   static_assigner_epoch: 30
    33.   use_varifocal_loss: True
    34.   loss_weight: {class: 1.0, iou: 2.5, dfl: 0.5}
    35.   static_assigner:
    36.     name: ATSSAssigner
    37.     topk: 9
    38.   assigner:
    39.     name: TaskAlignedAssigner
    40.     topk: 13
    41.     alpha: 1.0
    42.     beta: 6.0
    43.   nms:
    44.     name: MultiClassNMS
    45.     nms_top_k: 1000
    46.     keep_top_k: 300
    47.     score_threshold: 0.01
    48.     nms_threshold: 0.7

    (7)ppyoloe_plus_crn.yml

    1. worker_num: 4
    2. eval_height: &eval_height 640
    3. eval_width: &eval_width 640
    4. eval_size: &eval_size [*eval_height, *eval_width]
    5.  
    6. TrainReader:
    7.   sample_transforms:
    8.     - Decode: {}
    9.     - RandomDistort: {}
    10.     - RandomExpand: {fill_value: [123.675, 116.28, 103.53]}
    11.     - RandomCrop: {}
    12.     - RandomFlip: {}
    13.   batch_transforms:
    14.     - BatchRandomResize: {target_size: [320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736, 768], random_size: True, random_interp: True, keep_ratio: False}
    15.     - NormalizeImage: {mean: [0., 0., 0.], std: [1., 1., 1.], norm_type: none}
    16.     - Permute: {}
    17.     - PadGT: {}
    18.   batch_size: 8
    19.   shuffle: true
    20.   drop_last: true
    21.   use_shared_memory: true
    22.   collate_batch: true
    23.  
    24. EvalReader:
    25.   sample_transforms:
    26.     - Decode: {}
    27.     - Resize: {target_size: *eval_size, keep_ratio: False, interp: 2}
    28.     - NormalizeImage: {mean: [0., 0., 0.], std: [1., 1., 1.], norm_type: none}
    29.     - Permute: {}
    30.   batch_size: 2
    31.  
    32. TestReader:
    33.   inputs_def:
    34.     image_shape: [3, *eval_height, *eval_width]
    35.   sample_transforms:
    36.     - Decode: {}
    37.     - Resize: {target_size: *eval_size, keep_ratio: False, interp: 2}
    38.     - NormalizeImage: {mean: [0., 0., 0.], std: [1., 1., 1.], norm_type: none}
    39.     - Permute: {}
    40.   batch_size: 1

  • 相关阅读:
    【Java-框架-SpringMVC】(01) SpringMVC框架的简单创建与使用，快速上手 - 简易版
    CnosDB 签约京清能源，助力分布式光伏发电解决监测系统难题。
    基于springboot+vue的问卷调查系统
    用C语言解决三个整数比大小,x,y,z三个整数求最小整数，从键盘上输入3个不同的整数×，y,Z,请设计一个算法找出其中最小的数，并画出流程图。
    委派构造函数
    Spring IOC
    在kubernetes里使用AppArmor限制容器对资源的访问
    Qemu kvm_qemu详细教程
    【linux学习】Vim编辑器
    算法导论23章最小生成树习题—23.2练习
  • 原文地址：https://blog.csdn.net/chencaw/article/details/127945630