• YOLOv3目标检测全过程记录

    前提:

    软硬件环境：
    python 3.6.5
    Ubuntu18.04 LTS
    PyTorch 1.1.0
    CUDA 10.0
    cudnn 7.5.0
    GPU: NVIDIA TITAN XP

    一  准备数据集

    1. 准备图片

            这个可以需要自己拍摄,一般识别一件物体准备500张图片即可

    2. 进行数据标定

            这需要使用labelImg来进行数据的标定工作

            labelImg的安装方式如下所示:

    1. sudo apt-get install pyqt5-dev-tools
    2. sudo pip3 install -r requirements/requirements-linux-python3.txt
    3. make qt5py3
    4. python3 labelImg.py

            在运行第二行命令时可能会出现缺少pip3之类的提示，可以通过运行以下命令解决:

    sudo apt-get install python3-pip

     关于 labelImg的具体使用可以参考网上的具体教程

    二  下载并安装darknet

    1. 官方代码下载地址：https://github.com/pjreddie/darknet

    当然，你也可以采用以下命令进行下载

    git clone https://github.com/pjreddie/darknet

    2. 现在开始编译

    1. cd darknet
    2. sudo gedit  Makefile

    打开后，根据自己的需求修改文件夹，因为我用GPU，所以修改为GPU=1，CUDNN=1，OPENCV我设为0，因为我不使用摄像头。

    make

    接着用make命令进行编译，出现以下界面，编译成功：

    三  实验数据集整理与准备

            1. 将上一步解压的darknet文件夹放到home根目录下,然后再建立一个文件夹，命名为VOCdekit，再在VOCdekit文件夹下建立一个VOC2022，然后再在VOC2022下面创建三个文件夹,分别为Annotations,JPEGImages和ImageSets. 将标注的数据集放在 Annotations 下,即.xml格式的文件,  将所有用到的图片放到JPEGImages下,再在ImageSets下建立一个Main文件夹。
            2. 刚才建立这么多文件夹，解释一下它们要做的事：VOC2022建立，因为要制作VOC2022格式的数据集，源码中的路径命名都是按照这样的格式来的。那么在VOC2022中的Annotations又有什么用？它是为存放xml格式的标签文件的，也就是你刚才用Labelmg制作的标签文件，里面保存了每张图片的尺寸、物体类别、boundingbox等等信息，每一张xml文件都对应了JPEGImages中的一张图片。JPEGImages自然而然就是存放数据集图片的文件夹，也就是你自己收集的训练和测试图片。ImageSets里面本来时包含了三个文件夹的，但是我们只强调存放图像数据的Main文件，这个Main文件存着训练、测试和验证集的图片名称，也就是起到分割三个集的作用。
            3. 在VOC2022下建立一个test.py文件，将以下代码拷进去

    1. import os
    2. import random
    3.  
    4. trainval_percent = 0.1
    5. train_percent = 0.9
    6. xmlfilepath = 'Annotations'
    7. txtsavepath = 'ImageSets\Main'
    8. total_xml = os.listdir(xmlfilepath)
    9.  
    10. num = len(total_xml)
    11. list = range(num)
    12. tv = int(num * trainval_percent)
    13. tr = int(tv * train_percent)
    14. trainval = random.sample(list, tv)
    15. train = random.sample(trainval, tr)
    16.  
    17. ftrainval = open('ImageSets/Main/trainval.txt', 'w')
    18. ftest = open('ImageSets/Main/test.txt', 'w')
    19. ftrain = open('ImageSets/Main/train.txt', 'w')
    20. fval = open('ImageSets/Main/val.txt', 'w')
    21.  
    22. for i in list:
    23.     name = total_xml[i][:-4] + '\n'
    24.     if i in trainval:
    25.         ftrainval.write(name)
    26.         if i in train:
    27.             ftest.write(name)
    28.         else:
    29.             fval.write(name)
    30.     else:
    31.         ftrain.write(name)
    32.  
    33. ftrainval.close()
    34. ftrain.close()
    35. fval.close()
    36. ftest.close()

    4. 在VOC2022下打开终端,运行上述的python文件

    python test.py

    运行成功后会看到Main文件下多了四个txt文件

    四  加入自己的数据集

    1. 在darknet文件夹下打开终端(注意是在darknet文件下打开终端),然后输入如下命令

    wget https://pjreddie.com/media/files/voc_label.py

    如果不能下载的话也可以直接复制网址自己去下载, 下载完后将voc_label.py放到darknet文件夹下

    2. 进行voc_label.py文件的修改:

            (1)首先删除包含2007的所有项

            (2)将剩余的2012全部改为2022(注意:这里的2022即为上述我们所建立的VOC2022,如果是VOC2033则改为2033)

            (3)classes保存自己要检测的类别即可

    3. 再darknet文件夹下打开终端,输入如下命令:

    1. python voc_label.py
    2. cat 2022_train.txt 2022_val.txt  > train.txt

    注意:这里的2022_train.txt和后面的2022_val.txt要和自己上面所建立的VOC2022保持一致

    结束后，应该会发现，出现三个txt文件2022_train.txt,2022_val.txt,2022_test.txt，这是真正有用的三个文件。

    五 修改配置

    1. 在darknet文件下的cfg文件夹下面创建一个zp_test.data文件夹,.data文件夹的创建方式可以直接复制cfg文件夹下面已有的.data文件,然后做相应的修改即可

    具体的修改方式如下所示:

    1. classes=<你需要检测的类别数量>
    2. train = <2007_train.txt 文件所在的位置>
    3. valid = <2007_test.txt/2007_valid.txt 文件所在位置，这不太重要>
    4. names = <names文件所在位置>
    5. backup = <backup文件夹所在位置，没有就自己建一个>---这个即为最后数据训练完成后权重文件所存放的位置

    比如我的data文件的内容如下所示:

    1. classes=11
    2. train=/home/robot/darknet/2022_train.txt
    3. valid=/home/robot/darknet/2022_test.txt
    4. names=/home/robot/darknet/data/cell.names
    5. backup=backup/zp_test

    2. 在darknet文件下的data文件夹下面创建一个zp_test.names文件夹,.names文件夹的创建方式可以直接复制data文件夹下面已有的.names文件,然后做相应的修改即可

    具体的修改方式如下所示:即按照从上到下的顺序依次填写自己训练物品的名称

     

    3. 网络配置在cfg中，此次采用yolov3.cfg，这里需要修改cfg文件。每个[yolo]及其前的卷积层都要修改，主要修改卷积层中的filters的数量，数量计算公式是 filters= 3*(5+类别数），比如我这里有11个类别，filters=48. 还要修改[yolo]中的classes数，几个类别写几，我是11个类别，就写11。

    (注意:如果正常的话,应该只有三处需要修改的地方!!! 可以直接Ctrl+F搜索[yolo]进行查找,只有三次需要修改的地方!!!)

    一下是我的修改后的文件

    1. [net]
    2. # Testing
    3. # batch=1
    4. # subdivisions=1
    5. # Training
    6. batch=64
    7. subdivisions=16
    8. width=608
    9. height=608
    10. channels=3
    11. momentum=0.9
    12. decay=0.0005
    13. angle=0
    14. saturation = 1.5
    15. exposure = 1.5
    16. hue=.1
    17.  
    18. learning_rate=0.001
    19. burn_in=1000
    20. max_batches = 500200
    21. policy=steps
    22. steps=400000,450000
    23. scales=.1,.1
    24.  
    25. [convolutional]
    26. batch_normalize=1
    27. filters=32
    28. size=3
    29. stride=1
    30. pad=1
    31. activation=leaky
    32.  
    33. # Downsample
    34.  
    35. [convolutional]
    36. batch_normalize=1
    37. filters=64
    38. size=3
    39. stride=2
    40. pad=1
    41. activation=leaky
    42.  
    43. [convolutional]
    44. batch_normalize=1
    45. filters=32
    46. size=1
    47. stride=1
    48. pad=1
    49. activation=leaky
    50.  
    51. [convolutional]
    52. batch_normalize=1
    53. filters=64
    54. size=3
    55. stride=1
    56. pad=1
    57. activation=leaky
    58.  
    59. [shortcut]
    60. from=-3
    61. activation=linear
    62.  
    63. # Downsample
    64.  
    65. [convolutional]
    66. batch_normalize=1
    67. filters=128
    68. size=3
    69. stride=2
    70. pad=1
    71. activation=leaky
    72.  
    73. [convolutional]
    74. batch_normalize=1
    75. filters=64
    76. size=1
    77. stride=1
    78. pad=1
    79. activation=leaky
    80.  
    81. [convolutional]
    82. batch_normalize=1
    83. filters=128
    84. size=3
    85. stride=1
    86. pad=1
    87. activation=leaky
    88.  
    89. [shortcut]
    90. from=-3
    91. activation=linear
    92.  
    93. [convolutional]
    94. batch_normalize=1
    95. filters=64
    96. size=1
    97. stride=1
    98. pad=1
    99. activation=leaky
    100.  
    101. [convolutional]
    102. batch_normalize=1
    103. filters=128
    104. size=3
    105. stride=1
    106. pad=1
    107. activation=leaky
    108.  
    109. [shortcut]
    110. from=-3
    111. activation=linear
    112.  
    113. # Downsample
    114.  
    115. [convolutional]
    116. batch_normalize=1
    117. filters=256
    118. size=3
    119. stride=2
    120. pad=1
    121. activation=leaky
    122.  
    123. [convolutional]
    124. batch_normalize=1
    125. filters=128
    126. size=1
    127. stride=1
    128. pad=1
    129. activation=leaky
    130.  
    131. [convolutional]
    132. batch_normalize=1
    133. filters=256
    134. size=3
    135. stride=1
    136. pad=1
    137. activation=leaky
    138.  
    139. [shortcut]
    140. from=-3
    141. activation=linear
    142.  
    143. [convolutional]
    144. batch_normalize=1
    145. filters=128
    146. size=1
    147. stride=1
    148. pad=1
    149. activation=leaky
    150.  
    151. [convolutional]
    152. batch_normalize=1
    153. filters=256
    154. size=3
    155. stride=1
    156. pad=1
    157. activation=leaky
    158.  
    159. [shortcut]
    160. from=-3
    161. activation=linear
    162.  
    163. [convolutional]
    164. batch_normalize=1
    165. filters=128
    166. size=1
    167. stride=1
    168. pad=1
    169. activation=leaky
    170.  
    171. [convolutional]
    172. batch_normalize=1
    173. filters=256
    174. size=3
    175. stride=1
    176. pad=1
    177. activation=leaky
    178.  
    179. [shortcut]
    180. from=-3
    181. activation=linear
    182.  
    183. [convolutional]
    184. batch_normalize=1
    185. filters=128
    186. size=1
    187. stride=1
    188. pad=1
    189. activation=leaky
    190.  
    191. [convolutional]
    192. batch_normalize=1
    193. filters=256
    194. size=3
    195. stride=1
    196. pad=1
    197. activation=leaky
    198.  
    199. [shortcut]
    200. from=-3
    201. activation=linear
    202.  
    203.  
    204. [convolutional]
    205. batch_normalize=1
    206. filters=128
    207. size=1
    208. stride=1
    209. pad=1
    210. activation=leaky
    211.  
    212. [convolutional]
    213. batch_normalize=1
    214. filters=256
    215. size=3
    216. stride=1
    217. pad=1
    218. activation=leaky
    219.  
    220. [shortcut]
    221. from=-3
    222. activation=linear
    223.  
    224. [convolutional]
    225. batch_normalize=1
    226. filters=128
    227. size=1
    228. stride=1
    229. pad=1
    230. activation=leaky
    231.  
    232. [convolutional]
    233. batch_normalize=1
    234. filters=256
    235. size=3
    236. stride=1
    237. pad=1
    238. activation=leaky
    239.  
    240. [shortcut]
    241. from=-3
    242. activation=linear
    243.  
    244. [convolutional]
    245. batch_normalize=1
    246. filters=128
    247. size=1
    248. stride=1
    249. pad=1
    250. activation=leaky
    251.  
    252. [convolutional]
    253. batch_normalize=1
    254. filters=256
    255. size=3
    256. stride=1
    257. pad=1
    258. activation=leaky
    259.  
    260. [shortcut]
    261. from=-3
    262. activation=linear
    263.  
    264. [convolutional]
    265. batch_normalize=1
    266. filters=128
    267. size=1
    268. stride=1
    269. pad=1
    270. activation=leaky
    271.  
    272. [convolutional]
    273. batch_normalize=1
    274. filters=256
    275. size=3
    276. stride=1
    277. pad=1
    278. activation=leaky
    279.  
    280. [shortcut]
    281. from=-3
    282. activation=linear
    283.  
    284. # Downsample
    285.  
    286. [convolutional]
    287. batch_normalize=1
    288. filters=512
    289. size=3
    290. stride=2
    291. pad=1
    292. activation=leaky
    293.  
    294. [convolutional]
    295. batch_normalize=1
    296. filters=256
    297. size=1
    298. stride=1
    299. pad=1
    300. activation=leaky
    301.  
    302. [convolutional]
    303. batch_normalize=1
    304. filters=512
    305. size=3
    306. stride=1
    307. pad=1
    308. activation=leaky
    309.  
    310. [shortcut]
    311. from=-3
    312. activation=linear
    313.  
    314.  
    315. [convolutional]
    316. batch_normalize=1
    317. filters=256
    318. size=1
    319. stride=1
    320. pad=1
    321. activation=leaky
    322.  
    323. [convolutional]
    324. batch_normalize=1
    325. filters=512
    326. size=3
    327. stride=1
    328. pad=1
    329. activation=leaky
    330.  
    331. [shortcut]
    332. from=-3
    333. activation=linear
    334.  
    335.  
    336. [convolutional]
    337. batch_normalize=1
    338. filters=256
    339. size=1
    340. stride=1
    341. pad=1
    342. activation=leaky
    343.  
    344. [convolutional]
    345. batch_normalize=1
    346. filters=512
    347. size=3
    348. stride=1
    349. pad=1
    350. activation=leaky
    351.  
    352. [shortcut]
    353. from=-3
    354. activation=linear
    355.  
    356.  
    357. [convolutional]
    358. batch_normalize=1
    359. filters=256
    360. size=1
    361. stride=1
    362. pad=1
    363. activation=leaky
    364.  
    365. [convolutional]
    366. batch_normalize=1
    367. filters=512
    368. size=3
    369. stride=1
    370. pad=1
    371. activation=leaky
    372.  
    373. [shortcut]
    374. from=-3
    375. activation=linear
    376.  
    377. [convolutional]
    378. batch_normalize=1
    379. filters=256
    380. size=1
    381. stride=1
    382. pad=1
    383. activation=leaky
    384.  
    385. [convolutional]
    386. batch_normalize=1
    387. filters=512
    388. size=3
    389. stride=1
    390. pad=1
    391. activation=leaky
    392.  
    393. [shortcut]
    394. from=-3
    395. activation=linear
    396.  
    397.  
    398. [convolutional]
    399. batch_normalize=1
    400. filters=256
    401. size=1
    402. stride=1
    403. pad=1
    404. activation=leaky
    405.  
    406. [convolutional]
    407. batch_normalize=1
    408. filters=512
    409. size=3
    410. stride=1
    411. pad=1
    412. activation=leaky
    413.  
    414. [shortcut]
    415. from=-3
    416. activation=linear
    417.  
    418.  
    419. [convolutional]
    420. batch_normalize=1
    421. filters=256
    422. size=1
    423. stride=1
    424. pad=1
    425. activation=leaky
    426.  
    427. [convolutional]
    428. batch_normalize=1
    429. filters=512
    430. size=3
    431. stride=1
    432. pad=1
    433. activation=leaky
    434.  
    435. [shortcut]
    436. from=-3
    437. activation=linear
    438.  
    439. [convolutional]
    440. batch_normalize=1
    441. filters=256
    442. size=1
    443. stride=1
    444. pad=1
    445. activation=leaky
    446.  
    447. [convolutional]
    448. batch_normalize=1
    449. filters=512
    450. size=3
    451. stride=1
    452. pad=1
    453. activation=leaky
    454.  
    455. [shortcut]
    456. from=-3
    457. activation=linear
    458.  
    459. # Downsample
    460.  
    461. [convolutional]
    462. batch_normalize=1
    463. filters=1024
    464. size=3
    465. stride=2
    466. pad=1
    467. activation=leaky
    468.  
    469. [convolutional]
    470. batch_normalize=1
    471. filters=512
    472. size=1
    473. stride=1
    474. pad=1
    475. activation=leaky
    476.  
    477. [convolutional]
    478. batch_normalize=1
    479. filters=1024
    480. size=3
    481. stride=1
    482. pad=1
    483. activation=leaky
    484.  
    485. [shortcut]
    486. from=-3
    487. activation=linear
    488.  
    489. [convolutional]
    490. batch_normalize=1
    491. filters=512
    492. size=1
    493. stride=1
    494. pad=1
    495. activation=leaky
    496.  
    497. [convolutional]
    498. batch_normalize=1
    499. filters=1024
    500. size=3
    501. stride=1
    502. pad=1
    503. activation=leaky
    504.  
    505. [shortcut]
    506. from=-3
    507. activation=linear
    508.  
    509. [convolutional]
    510. batch_normalize=1
    511. filters=512
    512. size=1
    513. stride=1
    514. pad=1
    515. activation=leaky
    516.  
    517. [convolutional]
    518. batch_normalize=1
    519. filters=1024
    520. size=3
    521. stride=1
    522. pad=1
    523. activation=leaky
    524.  
    525. [shortcut]
    526. from=-3
    527. activation=linear
    528.  
    529. [convolutional]
    530. batch_normalize=1
    531. filters=512
    532. size=1
    533. stride=1
    534. pad=1
    535. activation=leaky
    536.  
    537. [convolutional]
    538. batch_normalize=1
    539. filters=1024
    540. size=3
    541. stride=1
    542. pad=1
    543. activation=leaky
    544.  
    545. [shortcut]
    546. from=-3
    547. activation=linear
    548.  
    549. ######################
    550.  
    551. [convolutional]
    552. batch_normalize=1
    553. filters=512
    554. size=1
    555. stride=1
    556. pad=1
    557. activation=leaky
    558.  
    559. [convolutional]
    560. batch_normalize=1
    561. size=3
    562. stride=1
    563. pad=1
    564. filters=1024
    565. activation=leaky
    566.  
    567. [convolutional]
    568. batch_normalize=1
    569. filters=512
    570. size=1
    571. stride=1
    572. pad=1
    573. activation=leaky
    574.  
    575. [convolutional]
    576. batch_normalize=1
    577. size=3
    578. stride=1
    579. pad=1
    580. filters=1024
    581. activation=leaky
    582.  
    583. [convolutional]
    584. batch_normalize=1
    585. filters=512
    586. size=1
    587. stride=1
    588. pad=1
    589. activation=leaky
    590.  
    591. [convolutional]
    592. batch_normalize=1
    593. size=3
    594. stride=1
    595. pad=1
    596. filters=1024
    597. activation=leaky
    598.  
    599. [convolutional]
    600. size=1
    601. stride=1
    602. pad=1
    603. filters=48
    604. activation=linear
    605.  
    606.  
    607. [yolo]
    608. mask = 6,7,8
    609. anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    610. classes=11
    611. num=9
    612. jitter=.3
    613. ignore_thresh = .7
    614. truth_thresh = 1
    615. random=1
    616.  
    617.  
    618. [route]
    619. layers = -4
    620.  
    621. [convolutional]
    622. batch_normalize=1
    623. filters=256
    624. size=1
    625. stride=1
    626. pad=1
    627. activation=leaky
    628.  
    629. [upsample]
    630. stride=2
    631.  
    632. [route]
    633. layers = -1, 61
    634.  
    635.  
    636.  
    637. [convolutional]
    638. batch_normalize=1
    639. filters=256
    640. size=1
    641. stride=1
    642. pad=1
    643. activation=leaky
    644.  
    645. [convolutional]
    646. batch_normalize=1
    647. size=3
    648. stride=1
    649. pad=1
    650. filters=512
    651. activation=leaky
    652.  
    653. [convolutional]
    654. batch_normalize=1
    655. filters=256
    656. size=1
    657. stride=1
    658. pad=1
    659. activation=leaky
    660.  
    661. [convolutional]
    662. batch_normalize=1
    663. size=3
    664. stride=1
    665. pad=1
    666. filters=512
    667. activation=leaky
    668.  
    669. [convolutional]
    670. batch_normalize=1
    671. filters=256
    672. size=1
    673. stride=1
    674. pad=1
    675. activation=leaky
    676.  
    677. [convolutional]
    678. batch_normalize=1
    679. size=3
    680. stride=1
    681. pad=1
    682. filters=512
    683. activation=leaky
    684.  
    685. [convolutional]
    686. size=1
    687. stride=1
    688. pad=1
    689. filters=48
    690. activation=linear
    691.  
    692.  
    693. [yolo]
    694. mask = 3,4,5
    695. anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    696. classes=11
    697. num=9
    698. jitter=.3
    699. ignore_thresh = .7
    700. truth_thresh = 1
    701. random=1
    702.  
    703.  
    704.  
    705. [route]
    706. layers = -4
    707.  
    708. [convolutional]
    709. batch_normalize=1
    710. filters=128
    711. size=1
    712. stride=1
    713. pad=1
    714. activation=leaky
    715.  
    716. [upsample]
    717. stride=2
    718.  
    719. [route]
    720. layers = -1, 36
    721.  
    722.  
    723.  
    724. [convolutional]
    725. batch_normalize=1
    726. filters=128
    727. size=1
    728. stride=1
    729. pad=1
    730. activation=leaky
    731.  
    732. [convolutional]
    733. batch_normalize=1
    734. size=3
    735. stride=1
    736. pad=1
    737. filters=256
    738. activation=leaky
    739.  
    740. [convolutional]
    741. batch_normalize=1
    742. filters=128
    743. size=1
    744. stride=1
    745. pad=1
    746. activation=leaky
    747.  
    748. [convolutional]
    749. batch_normalize=1
    750. size=3
    751. stride=1
    752. pad=1
    753. filters=256
    754. activation=leaky
    755.  
    756. [convolutional]
    757. batch_normalize=1
    758. filters=128
    759. size=1
    760. stride=1
    761. pad=1
    762. activation=leaky
    763.  
    764. [convolutional]
    765. batch_normalize=1
    766. size=3
    767. stride=1
    768. pad=1
    769. filters=256
    770. activation=leaky
    771.  
    772. [convolutional]
    773. size=1
    774. stride=1
    775. pad=1
    776. filters=48
    777. activation=linear
    778.  
    779.  
    780. [yolo]
    781. mask = 0,1,2
    782. anchors = 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    783. classes=11
    784. num=9
    785. jitter=.3
    786. ignore_thresh = .7
    787. truth_thresh = 1
    788. random=1

    4. 下载yolov3的初始权重，还要下载一下darknet53.conv.74的模型参数

    wget https://pjreddie.com/media/files/darknet53.conv.74

    如果无法下载的话,也可以直接复制网址自己进行下载,下载完后将darknet53.conv.74放在darknet文件夹下.

    六  进行数据训练

    在darknet中打开终端,输入如下命令进行训练:

    ./darknet detector train cfg/zp_test.data cfg/yolov3.cfg darknet53.conv.74

    这里再提醒一下，上面那句代码，zp_test.data换为你自己刚才建立的data文件，yolov3.cfg是因为我使用的是yolov3模型，如果用其他模型，就输入其他模型比如yolov3-tiny.cfg之类的，那么就要在第5步下载相对应的权重。 

    当这个数字下降到0.0x的时候说明已经训练可以. 最前面的29表示训练的轮数

     七  开始进行识别

            1. 将之前训练好的bakeup里面的权重文件.weights文件放到 /catkin_ws/src/darknet_ros/darknet_ros/yolo_network_config/weights里面

            2. 将之前改好的 .cfg 文件放到 /catkin_ws/src/darknet_ros/darknet_ros/yolo_network_config/cfg

    这个.cfg文件即为上面的yolov3.cfg文件,这里建议粘贴复制一份,即将yolov3.cfg拷贝一份命名比如为yolov3-voc-zp.cfg,然后将yolov3-voc-zp.cfg放到/catkin_ws/src/darknet_ros/darknet_ros/yolo_network_config/cfg下面. 这样可以避免命名重复

            3. 将这个/catkin_ws/src/darknet_ros/darknet_ros/config/yolov3-voc.yaml文件拷贝一份(位置也在当前文件夹,比如命名为yolov3-zp.yaml),然后将中的config_file，weight_file和names根据实际情况修改，其实就是之前添加进来的两个文件

     

     注意:这里的权重文件有许多,选择最后那个,因为训练的时候每一轮都会产生一个权重文件,然后将前面的权重文件进行覆盖,所以这里只写最后那个生成的权重文件即可

            4. 修改ros.yaml文件

    找到/home/robot/catkin_ws/src/darknet_ros/darknet_ros/config目录下的ros.yaml文件,进行摄像头的配置工作.根据自己的需要选择不同的摄像头的topic

    5. 创建相关的启动launch文件

    在该目录下:/home/robot/catkin_ws/src/darknet_ros/darknet_ros/launch, 创建一个launch文件,模板可以复制之前的,然后进行相应的修改即可,比如我创建了一个yolo_v3_zp.launch

     然后对里面的内容进行相应的修改,主要就修改下图中标注的地方即可,后面的yaml文件即为/catkin_ws/src/darknet_ros/darknet_ros/config目录下刚刚自己所创建的那个yaml文件

     6.  开始进行识别

    我使用的是realsense摄像头进行识别

    首先运行刚刚创建的那个launch文件,下面命令根据自己所创建的launch文件进行修改即可

    roslaunch darknet_ros yolo_v3_zp.launch

    然后摄像头的启动项,我使用的是realsense摄像头,具体代码配置自行编写

    rosrun realsense_test realsense_recognition

    下面是我的代码

    1. //realsense
    2. #include <librealsense2/rs.hpp>
    3. //ros
    4. # include "ros/ros.h"
    5. //C++
    6. # include <bits/stdc++.h>
    7. //Opencv
    8. # include "opencv2/opencv.hpp"
    9. # include <cv_bridge/cv_bridge.h>
    10. # include <image_transport/image_transport.h>
    11. //darknet
    12. # include "realsense_test/BoundingBoxes.h"
    13. # include "realsense_test/BoundingBox.h"
    14.  
    15. using namespace cv;
    16. using namespace std;
    17.  
    18. //物体识别
    19. struct Objects
    20. {
    21. 	int xmin, ymin, xmax, ymax; //一个物品的左上角和右下角坐标
    22. 	Objects(int a, int b, int c, int d) : xmin(a), ymin(b), xmax(c), ymax(d) {}
    23. };
    24. struct target_object
    25. {
    26.     int xmid, ymid, distance;  //物体中间坐标和距离
    27. };
    28. multimap<string, Objects> all_objects; //存储所有的物品信息,因为一张图片中可能会出现多种一样的东西,所以用multimap
    29.  
    30. void ObjectCallback(const realsense_test::BoundingBoxes::ConstPtr &msg)
    31. {
    32.     for (int i = 0; i < msg->bounding_boxes.size(); ++i)
    33.     {
    34. 		realsense_test::BoundingBox temp = msg->bounding_boxes[i];
    35. 		if (temp.probability > 0.6)
    36.         { //大于0.6,我们就认为可信
    37. 			all_objects.insert(make_pair(temp.Class, Objects(temp.xmin, temp.ymin, temp.xmax, temp.ymax)));
    38. 		}
    39. 	}
    40. }
    41.  
    42. //测量物体位置(返回物体中心点坐标和物体的距离)
    43. target_object ObjectMark(Mat &color, Mat &depth, int xmin, int ymin, int xmax, int ymax)
    44. {
    45.     //计算图像中间30*30个像素点深度的众数
    46.     int xmid = (int)(xmin + xmax) * 0.5;
    47.     int ymid = (int)(ymin + ymax) * 0.5; 
    48.     map<int, int> depthmap;  //用于计算众数
    49.     for(int i = ymid - 10; i <= ymid + 10; i ++)
    50.     {
    51.         const uint16_t *pD = depth.ptr<uint16_t>(i);
    52.         for(int j = xmid - 10; j <= xmid + 10; j ++)
    53.         {
    54.             int distance;
    55.             distance = *(pD + j);
    56.             depthmap[distance] ++;
    57.         }
    58.     }
    59.     int max = -1;
    60.     int temp_distance = -1;
    61.     for(auto value : depthmap)
    62.     {
    63.         if(value.second > max)
    64.         {
    65.             max = value.second;
    66.             temp_distance = value.first;
    67.         }
    68.     }
    69.     depthmap.clear();
    70.  
    71.     int final_distance = temp_distance;
    72.     if(final_distance < 0)  final_distance = 0;
    73.  
    74.     //int final_distance = depth.at<uint16_t>(xmid, ymid);
    75.  
    76.     putText(color, to_string(final_distance), Point(xmid, ymid), FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2, 8, false);
    77.     rectangle(color, Point(xmin, ymin), Point(xmax, ymax), Scalar(0, 255, 0), 3);
    78.     
    79.     target_object tobj;
    80.     tobj.distance = final_distance;
    81.     tobj.xmid = xmid;
    82.     tobj.ymid = ymid;
    83.  
    84.     //imshow("color", color);
    85.     return tobj;
    86. }
    87.  
    88. int main(int argc, char *argv[])
    89. {
    90.     //=================ros初始化==============
    91. 	ros::init(argc, argv, "move_test");
    92. 	ros::NodeHandle n;
    93.     //realsense RGB图像发布者
    94. 	image_transport::ImageTransport it(n);
    95.     image_transport::Publisher rgb_pub = it.advertise("realsense/RGBImage", 1);
    96.     cout<<"11111"<<endl;
    97.     ros::Subscriber sub = n.subscribe("/darknet_ros/bounding_boxes", 2, ObjectCallback);
    98.     cout<<"222222"<<endl;
    99.     //开启realsense
    100.     //创建数据管道
    101.     rs2::pipeline p;
    102.     rs2::config pipe_config;
    103.     pipe_config.enable_stream(RS2_STREAM_DEPTH,1280,720,RS2_FORMAT_Z16,30);
    104.     pipe_config.enable_stream(RS2_STREAM_COLOR,1280,720,RS2_FORMAT_RGB8,30);
    105.     //start()函数返回数据管道的profile
    106.     rs2::pipeline_profile profile = p.start(pipe_config);
    107.     Mat color, depth;
    108.     while(waitKey(30) != 27)
    109.     {
    110.         //捕获RGB和深度图像
    111.         rs2::frameset frames = p.wait_for_frames();
    112.         rs2::video_frame rs_color = frames.get_color_frame();
    113.         rs2::depth_frame rs_depth = frames.get_depth_frame();
    114.         //将RBG图像转为opencv类型
    115.         const int wc = rs_color.as<rs2::video_frame>().get_width();
    116.         const int hc = rs_color.as<rs2::video_frame>().get_height();
    117.         Mat color1(Size(wc, hc), CV_8UC3, (void*)rs_color.get_data(), Mat::AUTO_STEP);
    118.         cvtColor(color1, color, cv::COLOR_RGB2BGR);
    119.         //将深度图像转为opencv类型
    120.         const int wd = rs_depth.as<rs2::depth_frame>().get_width();
    121.         const int hd = rs_depth.as<rs2::depth_frame>().get_height();
    122.         Mat depth(Size(wd, hd), CV_16U, (void*)rs_depth.get_data(), Mat::AUTO_STEP);
    123.         //发布RGB图像
    124.         sensor_msgs::ImagePtr msg = cv_bridge::CvImage(std_msgs::Header(), "bgr8", color).toImageMsg();
    125.         ros::Rate loop_rate(30);
    126.         loop_rate.sleep();
    127.         ros::spinOnce();
    128.         rgb_pub.publish(msg);
    129.         target_object tobj;   //目标物体
    130.         //imshow("zp",color);
    131.         for(auto value : all_objects)
    132.         {
    133.             tobj = ObjectMark(color, depth, value.second.xmin, 
    134.                         value.second.ymin, value.second.xmax, value.second.ymax);
    135.             ros::Rate loop_rate(100);
    136.             loop_rate.sleep();
    137.         }
    138.         all_objects.clear();
    139.     }
    140.     return 0;
    141. }

  • 相关阅读:
    Java安全—CommonsCollections7
    K8S 实用工具之一 - 如何合并多个 kubeconfig？
    Node.js躬行记（17）——UmiJS版本升级
    如何递归对比两个文件夹当中npy文件的内容
    人工神经网络可以做什么,人工神经网络有什么用
    Java拦截所有接口请求并过滤请求头内容
    荣耀70和荣耀70pro哪个值得买 两者配置对比
    Hadoop3教程（一）：Hadoop的定义、组成及全生态概览
    Intel汇编语言程序设计(第7版)第六章编程练习题答案
    MySQL之如何排查死锁
  • 原文地址：https://blog.csdn.net/qq_58011370/article/details/125541838