├── models
    ├── __init__.py
    ├── __pycache__
    │   ├── common.cpython-37.pyc
    │   ├── common.cpython-38.pyc
    │   ├── yolo.cpython-37.pyc
    │   ├── yolo.cpython-38.pyc
    │   ├── __init__.cpython-37.pyc
    │   ├── __init__.cpython-38.pyc
    │   ├── experimental.cpython-37.pyc
    │   └── experimental.cpython-38.pyc
    ├── hub
    │   ├── yolov3-tiny.yaml
    │   ├── yolov5-fpn.yaml
    │   ├── yolov5-panet.yaml
    │   ├── yolov3.yaml
    │   ├── yolov3-spp.yaml
    │   ├── yolov5-p2.yaml
    │   ├── yolov5-p6.yaml
    │   ├── yolov5l6.yaml
    │   ├── yolov5m6.yaml
    │   ├── yolov5s6.yaml
    │   ├── yolov5x6.yaml
    │   ├── yolov5-p7.yaml
    │   └── anchors.yaml
    ├── yolov5l.yaml
    ├── yolov5m.yaml
    ├── yolov5s.yaml
    ├── yolov5x.yaml
    ├── export.py
    ├── experimental.py
    ├── yolo.py
    └── common.py
├── screenshot
    ├── 1.jpeg
    ├── 2.png
    ├── 3.jpg
    └── qrcode.png
├── data
    ├── images
    │   └── zidane.jpg
    ├── voc.yaml
    ├── hyp.finetune.yaml
    ├── scripts
    │   ├── get_coco.sh
    │   └── get_voc.sh
    ├── coco128.yaml
    ├── hyp.scratch.yaml
    └── coco.yaml
├── runs
    └── detect
    │   └── exp3
    │       └── zidane.jpg
├── weights
    └── download_weights.sh
├── Dockerfile
├── hubconf.py
├── README.md
├── detect_camera.py
└── detect_photo.py


/models/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/screenshot/1.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/screenshot/1.jpeg


--------------------------------------------------------------------------------
/screenshot/2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/screenshot/2.png


--------------------------------------------------------------------------------
/screenshot/3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/screenshot/3.jpg


--------------------------------------------------------------------------------
/data/images/zidane.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/data/images/zidane.jpg


--------------------------------------------------------------------------------
/screenshot/qrcode.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/screenshot/qrcode.png


--------------------------------------------------------------------------------
/runs/detect/exp3/zidane.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/runs/detect/exp3/zidane.jpg


--------------------------------------------------------------------------------
/models/__pycache__/common.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/common.cpython-37.pyc


--------------------------------------------------------------------------------
/models/__pycache__/common.cpython-38.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/common.cpython-38.pyc


--------------------------------------------------------------------------------
/models/__pycache__/yolo.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/yolo.cpython-37.pyc


--------------------------------------------------------------------------------
/models/__pycache__/yolo.cpython-38.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/yolo.cpython-38.pyc


--------------------------------------------------------------------------------
/models/__pycache__/__init__.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/__init__.cpython-37.pyc


--------------------------------------------------------------------------------
/models/__pycache__/__init__.cpython-38.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/__init__.cpython-38.pyc


--------------------------------------------------------------------------------
/models/__pycache__/experimental.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/experimental.cpython-37.pyc


--------------------------------------------------------------------------------
/models/__pycache__/experimental.cpython-38.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/HEAD/models/__pycache__/experimental.cpython-38.pyc


--------------------------------------------------------------------------------
/weights/download_weights.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Download latest models from https://github.com/ultralytics/yolov5/releases
 3 | # Usage:
 4 | #    $ bash weights/download_weights.sh
 5 | 
 6 | python - <<EOF
 7 | from utils.google_utils import attempt_download
 8 | 
 9 | for x in ['s', 'm', 'l', 'x']:
10 |     attempt_download(f'yolov5{x}.pt')
11 | 
12 | EOF
13 | 


--------------------------------------------------------------------------------
/data/voc.yaml:
--------------------------------------------------------------------------------
 1 | # PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC/
 2 | # Train command: python train.py --data voc.yaml
 3 | # Default dataset location is next to /yolov5:
 4 | #   /parent_folder
 5 | #     /VOC
 6 | #     /yolov5
 7 | 
 8 | 
 9 | # download command/URL (optional)
10 | download: bash data/scripts/get_voc.sh
11 | 
12 | # train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
13 | train: ../VOC/images/train/  # 16551 images
14 | val: ../VOC/images/val/  # 4952 images
15 | 
16 | # number of classes
17 | nc: 20
18 | 
19 | # class names
20 | names: [ 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog',
21 |          'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor' ]
22 | 


--------------------------------------------------------------------------------
/data/hyp.finetune.yaml:
--------------------------------------------------------------------------------
 1 | # Hyperparameters for VOC finetuning
 2 | # python train.py --batch 64 --weights yolov5m.pt --data voc.yaml --img 512 --epochs 50
 3 | # See tutorials for hyperparameter evolution https://github.com/ultralytics/yolov5#tutorials
 4 | 
 5 | 
 6 | # Hyperparameter Evolution Results
 7 | # Generations: 306
 8 | #                   P         R     mAP.5 mAP.5:.95       box       obj       cls
 9 | # Metrics:        0.6     0.936     0.896     0.684    0.0115   0.00805   0.00146
10 | 
11 | lr0: 0.0032
12 | lrf: 0.12
13 | momentum: 0.843
14 | weight_decay: 0.00036
15 | warmup_epochs: 2.0
16 | warmup_momentum: 0.5
17 | warmup_bias_lr: 0.05
18 | box: 0.0296
19 | cls: 0.243
20 | cls_pw: 0.631
21 | obj: 0.301
22 | obj_pw: 0.911
23 | iou_t: 0.2
24 | anchor_t: 2.91
25 | # anchors: 3.63
26 | fl_gamma: 0.0
27 | hsv_h: 0.0138
28 | hsv_s: 0.664
29 | hsv_v: 0.464
30 | degrees: 0.373
31 | translate: 0.245
32 | scale: 0.898
33 | shear: 0.602
34 | perspective: 0.0
35 | flipud: 0.00856
36 | fliplr: 0.5
37 | mosaic: 1.0
38 | mixup: 0.243
39 | 


--------------------------------------------------------------------------------
/data/scripts/get_coco.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # COCO 2017 dataset http://cocodataset.org
 3 | # Download command: bash data/scripts/get_coco.sh
 4 | # Train command: python train.py --data coco.yaml
 5 | # Default dataset location is next to /yolov5:
 6 | #   /parent_folder
 7 | #     /coco
 8 | #     /yolov5
 9 | 
10 | # Download/unzip labels
11 | d='../' # unzip directory
12 | url=https://github.com/ultralytics/yolov5/releases/download/v1.0/
13 | f='coco2017labels.zip' # or 'coco2017labels-segments.zip', 68 MB
14 | echo 'Downloading' $url$f ' ...'
15 | curl -L $url$f -o $f && unzip -q $f -d $d && rm $f & # download, unzip, remove in background
16 | 
17 | # Download/unzip images
18 | d='../coco/images' # unzip directory
19 | url=http://images.cocodataset.org/zips/
20 | f1='train2017.zip' # 19G, 118k images
21 | f2='val2017.zip'   # 1G, 5k images
22 | f3='test2017.zip'  # 7G, 41k images (optional)
23 | for f in $f1 $f2; do
24 |   echo 'Downloading' $url$f '...'
25 |   curl -L $url$f -o $f && unzip -q $f -d $d && rm $f & # download, unzip, remove in background
26 | done
27 | wait # finish background tasks
28 | 


--------------------------------------------------------------------------------
/models/hub/yolov3-tiny.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,14, 23,27, 37,58]  # P4/16
 9 |   - [81,82, 135,169, 344,319]  # P5/32
10 | 
11 | # YOLOv3-tiny backbone
12 | backbone:
13 |   # [from, number, module, args]
14 |   [[-1, 1, Conv, [16, 3, 1]],  # 0
15 |    [-1, 1, nn.MaxPool2d, [2, 2, 0]],  # 1-P1/2
16 |    [-1, 1, Conv, [32, 3, 1]],
17 |    [-1, 1, nn.MaxPool2d, [2, 2, 0]],  # 3-P2/4
18 |    [-1, 1, Conv, [64, 3, 1]],
19 |    [-1, 1, nn.MaxPool2d, [2, 2, 0]],  # 5-P3/8
20 |    [-1, 1, Conv, [128, 3, 1]],
21 |    [-1, 1, nn.MaxPool2d, [2, 2, 0]],  # 7-P4/16
22 |    [-1, 1, Conv, [256, 3, 1]],
23 |    [-1, 1, nn.MaxPool2d, [2, 2, 0]],  # 9-P5/32
24 |    [-1, 1, Conv, [512, 3, 1]],
25 |    [-1, 1, nn.ZeroPad2d, [[0, 1, 0, 1]]],  # 11
26 |    [-1, 1, nn.MaxPool2d, [2, 1, 0]],  # 12
27 |   ]
28 | 
29 | # YOLOv3-tiny head
30 | head:
31 |   [[-1, 1, Conv, [1024, 3, 1]],
32 |    [-1, 1, Conv, [256, 1, 1]],
33 |    [-1, 1, Conv, [512, 3, 1]],  # 15 (P5/32-large)
34 | 
35 |    [-2, 1, Conv, [128, 1, 1]],
36 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
37 |    [[-1, 8], 1, Concat, [1]],  # cat backbone P4
38 |    [-1, 1, Conv, [256, 3, 1]],  # 19 (P4/16-medium)
39 | 
40 |    [[19, 15], 1, Detect, [nc, anchors]],  # Detect(P4, P5)
41 |   ]
42 | 


--------------------------------------------------------------------------------
/models/hub/yolov5-fpn.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # YOLOv5 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Focus, [64, 3]],  # 0-P1/2
16 |    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
17 |    [-1, 3, Bottleneck, [128]],
18 |    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
19 |    [-1, 9, BottleneckCSP, [256]],
20 |    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
21 |    [-1, 9, BottleneckCSP, [512]],
22 |    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
23 |    [-1, 1, SPP, [1024, [5, 9, 13]]],
24 |    [-1, 6, BottleneckCSP, [1024]],  # 9
25 |   ]
26 | 
27 | # YOLOv5 FPN head
28 | head:
29 |   [[-1, 3, BottleneckCSP, [1024, False]],  # 10 (P5/32-large)
30 | 
31 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
32 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
33 |    [-1, 1, Conv, [512, 1, 1]],
34 |    [-1, 3, BottleneckCSP, [512, False]],  # 14 (P4/16-medium)
35 | 
36 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
37 |    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
38 |    [-1, 1, Conv, [256, 1, 1]],
39 |    [-1, 3, BottleneckCSP, [256, False]],  # 18 (P3/8-small)
40 | 
41 |    [[18, 14, 10], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
42 |   ]
43 | 


--------------------------------------------------------------------------------
/models/yolov5l.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # YOLOv5 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Focus, [64, 3]],  # 0-P1/2
16 |    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
17 |    [-1, 3, C3, [128]],
18 |    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
19 |    [-1, 9, C3, [256]],
20 |    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
21 |    [-1, 9, C3, [512]],
22 |    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
23 |    [-1, 1, SPP, [1024, [5, 9, 13]]],
24 |    [-1, 3, C3, [1024, False]],  # 9
25 |   ]
26 | 
27 | # YOLOv5 head
28 | head:
29 |   [[-1, 1, Conv, [512, 1, 1]],
30 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
31 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
32 |    [-1, 3, C3, [512, False]],  # 13
33 | 
34 |    [-1, 1, Conv, [256, 1, 1]],
35 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
36 |    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
37 |    [-1, 3, C3, [256, False]],  # 17 (P3/8-small)
38 | 
39 |    [-1, 1, Conv, [256, 3, 2]],
40 |    [[-1, 14], 1, Concat, [1]],  # cat head P4
41 |    [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)
42 | 
43 |    [-1, 1, Conv, [512, 3, 2]],
44 |    [[-1, 10], 1, Concat, [1]],  # cat head P5
45 |    [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)
46 | 
47 |    [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
48 |   ]
49 | 


--------------------------------------------------------------------------------
/models/yolov5m.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 0.67  # model depth multiple
 4 | width_multiple: 0.75  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # YOLOv5 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Focus, [64, 3]],  # 0-P1/2
16 |    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
17 |    [-1, 3, C3, [128]],
18 |    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
19 |    [-1, 9, C3, [256]],
20 |    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
21 |    [-1, 9, C3, [512]],
22 |    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
23 |    [-1, 1, SPP, [1024, [5, 9, 13]]],
24 |    [-1, 3, C3, [1024, False]],  # 9
25 |   ]
26 | 
27 | # YOLOv5 head
28 | head:
29 |   [[-1, 1, Conv, [512, 1, 1]],
30 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
31 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
32 |    [-1, 3, C3, [512, False]],  # 13
33 | 
34 |    [-1, 1, Conv, [256, 1, 1]],
35 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
36 |    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
37 |    [-1, 3, C3, [256, False]],  # 17 (P3/8-small)
38 | 
39 |    [-1, 1, Conv, [256, 3, 2]],
40 |    [[-1, 14], 1, Concat, [1]],  # cat head P4
41 |    [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)
42 | 
43 |    [-1, 1, Conv, [512, 3, 2]],
44 |    [[-1, 10], 1, Concat, [1]],  # cat head P5
45 |    [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)
46 | 
47 |    [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
48 |   ]
49 | 


--------------------------------------------------------------------------------
/models/yolov5s.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 0.33  # model depth multiple
 4 | width_multiple: 0.50  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # YOLOv5 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Focus, [64, 3]],  # 0-P1/2
16 |    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
17 |    [-1, 3, C3, [128]],
18 |    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
19 |    [-1, 9, C3, [256]],
20 |    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
21 |    [-1, 9, C3, [512]],
22 |    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
23 |    [-1, 1, SPP, [1024, [5, 9, 13]]],
24 |    [-1, 3, C3, [1024, False]],  # 9
25 |   ]
26 | 
27 | # YOLOv5 head
28 | head:
29 |   [[-1, 1, Conv, [512, 1, 1]],
30 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
31 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
32 |    [-1, 3, C3, [512, False]],  # 13
33 | 
34 |    [-1, 1, Conv, [256, 1, 1]],
35 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
36 |    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
37 |    [-1, 3, C3, [256, False]],  # 17 (P3/8-small)
38 | 
39 |    [-1, 1, Conv, [256, 3, 2]],
40 |    [[-1, 14], 1, Concat, [1]],  # cat head P4
41 |    [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)
42 | 
43 |    [-1, 1, Conv, [512, 3, 2]],
44 |    [[-1, 10], 1, Concat, [1]],  # cat head P5
45 |    [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)
46 | 
47 |    [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
48 |   ]
49 | 


--------------------------------------------------------------------------------
/models/yolov5x.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.33  # model depth multiple
 4 | width_multiple: 1.25  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # YOLOv5 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Focus, [64, 3]],  # 0-P1/2
16 |    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
17 |    [-1, 3, C3, [128]],
18 |    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
19 |    [-1, 9, C3, [256]],
20 |    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
21 |    [-1, 9, C3, [512]],
22 |    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
23 |    [-1, 1, SPP, [1024, [5, 9, 13]]],
24 |    [-1, 3, C3, [1024, False]],  # 9
25 |   ]
26 | 
27 | # YOLOv5 head
28 | head:
29 |   [[-1, 1, Conv, [512, 1, 1]],
30 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
31 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
32 |    [-1, 3, C3, [512, False]],  # 13
33 | 
34 |    [-1, 1, Conv, [256, 1, 1]],
35 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
36 |    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
37 |    [-1, 3, C3, [256, False]],  # 17 (P3/8-small)
38 | 
39 |    [-1, 1, Conv, [256, 3, 2]],
40 |    [[-1, 14], 1, Concat, [1]],  # cat head P4
41 |    [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)
42 | 
43 |    [-1, 1, Conv, [512, 3, 2]],
44 |    [[-1, 10], 1, Concat, [1]],  # cat head P5
45 |    [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)
46 | 
47 |    [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
48 |   ]
49 | 


--------------------------------------------------------------------------------
/data/coco128.yaml:
--------------------------------------------------------------------------------
 1 | # COCO 2017 dataset http://cocodataset.org - first 128 training images
 2 | # Train command: python train.py --data coco128.yaml
 3 | # Default dataset location is next to /yolov5:
 4 | #   /parent_folder
 5 | #     /coco128
 6 | #     /yolov5
 7 | 
 8 | 
 9 | # download command/URL (optional)
10 | download: https://github.com/ultralytics/yolov5/releases/download/v1.0/coco128.zip
11 | 
12 | # train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
13 | train: ../coco128/images/train2017/  # 128 images
14 | val: ../coco128/images/train2017/  # 128 images
15 | 
16 | # number of classes
17 | nc: 80
18 | 
19 | # class names
20 | names: [ 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
21 |          'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
22 |          'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
23 |          'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
24 |          'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
25 |          'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
26 |          'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
27 |          'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear',
28 |          'hair drier', 'toothbrush' ]
29 | 


--------------------------------------------------------------------------------
/models/hub/yolov5-panet.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # YOLOv5 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Focus, [64, 3]],  # 0-P1/2
16 |    [-1, 1, Conv, [128, 3, 2]],  # 1-P2/4
17 |    [-1, 3, BottleneckCSP, [128]],
18 |    [-1, 1, Conv, [256, 3, 2]],  # 3-P3/8
19 |    [-1, 9, BottleneckCSP, [256]],
20 |    [-1, 1, Conv, [512, 3, 2]],  # 5-P4/16
21 |    [-1, 9, BottleneckCSP, [512]],
22 |    [-1, 1, Conv, [1024, 3, 2]],  # 7-P5/32
23 |    [-1, 1, SPP, [1024, [5, 9, 13]]],
24 |    [-1, 3, BottleneckCSP, [1024, False]],  # 9
25 |   ]
26 | 
27 | # YOLOv5 PANet head
28 | head:
29 |   [[-1, 1, Conv, [512, 1, 1]],
30 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
31 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P4
32 |    [-1, 3, BottleneckCSP, [512, False]],  # 13
33 | 
34 |    [-1, 1, Conv, [256, 1, 1]],
35 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
36 |    [[-1, 4], 1, Concat, [1]],  # cat backbone P3
37 |    [-1, 3, BottleneckCSP, [256, False]],  # 17 (P3/8-small)
38 | 
39 |    [-1, 1, Conv, [256, 3, 2]],
40 |    [[-1, 14], 1, Concat, [1]],  # cat head P4
41 |    [-1, 3, BottleneckCSP, [512, False]],  # 20 (P4/16-medium)
42 | 
43 |    [-1, 1, Conv, [512, 3, 2]],
44 |    [[-1, 10], 1, Concat, [1]],  # cat head P5
45 |    [-1, 3, BottleneckCSP, [1024, False]],  # 23 (P5/32-large)
46 | 
47 |    [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
48 |   ]
49 | 


--------------------------------------------------------------------------------
/data/hyp.scratch.yaml:
--------------------------------------------------------------------------------
 1 | # Hyperparameters for COCO training from scratch
 2 | # python train.py --batch 40 --cfg yolov5m.yaml --weights '' --data coco.yaml --img 640 --epochs 300
 3 | # See tutorials for hyperparameter evolution https://github.com/ultralytics/yolov5#tutorials
 4 | 
 5 | 
 6 | lr0: 0.01  # initial learning rate (SGD=1E-2, Adam=1E-3)
 7 | lrf: 0.2  # final OneCycleLR learning rate (lr0 * lrf)
 8 | momentum: 0.937  # SGD momentum/Adam beta1
 9 | weight_decay: 0.0005  # optimizer weight decay 5e-4
10 | warmup_epochs: 3.0  # warmup epochs (fractions ok)
11 | warmup_momentum: 0.8  # warmup initial momentum
12 | warmup_bias_lr: 0.1  # warmup initial bias lr
13 | box: 0.05  # box loss gain
14 | cls: 0.5  # cls loss gain
15 | cls_pw: 1.0  # cls BCELoss positive_weight
16 | obj: 1.0  # obj loss gain (scale with pixels)
17 | obj_pw: 1.0  # obj BCELoss positive_weight
18 | iou_t: 0.20  # IoU training threshold
19 | anchor_t: 4.0  # anchor-multiple threshold
20 | # anchors: 3  # anchors per output layer (0 to ignore)
21 | fl_gamma: 0.0  # focal loss gamma (efficientDet default gamma=1.5)
22 | hsv_h: 0.015  # image HSV-Hue augmentation (fraction)
23 | hsv_s: 0.7  # image HSV-Saturation augmentation (fraction)
24 | hsv_v: 0.4  # image HSV-Value augmentation (fraction)
25 | degrees: 0.0  # image rotation (+/- deg)
26 | translate: 0.1  # image translation (+/- fraction)
27 | scale: 0.5  # image scale (+/- gain)
28 | shear: 0.0  # image shear (+/- deg)
29 | perspective: 0.0  # image perspective (+/- fraction), range 0-0.001
30 | flipud: 0.0  # image flip up-down (probability)
31 | fliplr: 0.5  # image flip left-right (probability)
32 | mosaic: 1.0  # image mosaic (probability)
33 | mixup: 0.0  # image mixup (probability)
34 | 


--------------------------------------------------------------------------------
/models/hub/yolov3.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # darknet53 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Conv, [32, 3, 1]],  # 0
16 |    [-1, 1, Conv, [64, 3, 2]],  # 1-P1/2
17 |    [-1, 1, Bottleneck, [64]],
18 |    [-1, 1, Conv, [128, 3, 2]],  # 3-P2/4
19 |    [-1, 2, Bottleneck, [128]],
20 |    [-1, 1, Conv, [256, 3, 2]],  # 5-P3/8
21 |    [-1, 8, Bottleneck, [256]],
22 |    [-1, 1, Conv, [512, 3, 2]],  # 7-P4/16
23 |    [-1, 8, Bottleneck, [512]],
24 |    [-1, 1, Conv, [1024, 3, 2]],  # 9-P5/32
25 |    [-1, 4, Bottleneck, [1024]],  # 10
26 |   ]
27 | 
28 | # YOLOv3 head
29 | head:
30 |   [[-1, 1, Bottleneck, [1024, False]],
31 |    [-1, 1, Conv, [512, [1, 1]]],
32 |    [-1, 1, Conv, [1024, 3, 1]],
33 |    [-1, 1, Conv, [512, 1, 1]],
34 |    [-1, 1, Conv, [1024, 3, 1]],  # 15 (P5/32-large)
35 | 
36 |    [-2, 1, Conv, [256, 1, 1]],
37 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
38 |    [[-1, 8], 1, Concat, [1]],  # cat backbone P4
39 |    [-1, 1, Bottleneck, [512, False]],
40 |    [-1, 1, Bottleneck, [512, False]],
41 |    [-1, 1, Conv, [256, 1, 1]],
42 |    [-1, 1, Conv, [512, 3, 1]],  # 22 (P4/16-medium)
43 | 
44 |    [-2, 1, Conv, [128, 1, 1]],
45 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
46 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P3
47 |    [-1, 1, Bottleneck, [256, False]],
48 |    [-1, 2, Bottleneck, [256, False]],  # 27 (P3/8-small)
49 | 
50 |    [[27, 22, 15], 1, Detect, [nc, anchors]],   # Detect(P3, P4, P5)
51 |   ]
52 | 


--------------------------------------------------------------------------------
/models/hub/yolov3-spp.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [10,13, 16,30, 33,23]  # P3/8
 9 |   - [30,61, 62,45, 59,119]  # P4/16
10 |   - [116,90, 156,198, 373,326]  # P5/32
11 | 
12 | # darknet53 backbone
13 | backbone:
14 |   # [from, number, module, args]
15 |   [[-1, 1, Conv, [32, 3, 1]],  # 0
16 |    [-1, 1, Conv, [64, 3, 2]],  # 1-P1/2
17 |    [-1, 1, Bottleneck, [64]],
18 |    [-1, 1, Conv, [128, 3, 2]],  # 3-P2/4
19 |    [-1, 2, Bottleneck, [128]],
20 |    [-1, 1, Conv, [256, 3, 2]],  # 5-P3/8
21 |    [-1, 8, Bottleneck, [256]],
22 |    [-1, 1, Conv, [512, 3, 2]],  # 7-P4/16
23 |    [-1, 8, Bottleneck, [512]],
24 |    [-1, 1, Conv, [1024, 3, 2]],  # 9-P5/32
25 |    [-1, 4, Bottleneck, [1024]],  # 10
26 |   ]
27 | 
28 | # YOLOv3-SPP head
29 | head:
30 |   [[-1, 1, Bottleneck, [1024, False]],
31 |    [-1, 1, SPP, [512, [5, 9, 13]]],
32 |    [-1, 1, Conv, [1024, 3, 1]],
33 |    [-1, 1, Conv, [512, 1, 1]],
34 |    [-1, 1, Conv, [1024, 3, 1]],  # 15 (P5/32-large)
35 | 
36 |    [-2, 1, Conv, [256, 1, 1]],
37 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
38 |    [[-1, 8], 1, Concat, [1]],  # cat backbone P4
39 |    [-1, 1, Bottleneck, [512, False]],
40 |    [-1, 1, Bottleneck, [512, False]],
41 |    [-1, 1, Conv, [256, 1, 1]],
42 |    [-1, 1, Conv, [512, 3, 1]],  # 22 (P4/16-medium)
43 | 
44 |    [-2, 1, Conv, [128, 1, 1]],
45 |    [-1, 1, nn.Upsample, [None, 2, 'nearest']],
46 |    [[-1, 6], 1, Concat, [1]],  # cat backbone P3
47 |    [-1, 1, Bottleneck, [256, False]],
48 |    [-1, 2, Bottleneck, [256, False]],  # 27 (P3/8-small)
49 | 
50 |    [[27, 22, 15], 1, Detect, [nc, anchors]],   # Detect(P3, P4, P5)
51 |   ]
52 | 


--------------------------------------------------------------------------------
/data/coco.yaml:
--------------------------------------------------------------------------------
 1 | # COCO 2017 dataset http://cocodataset.org
 2 | # Train command: python train.py --data coco.yaml
 3 | # Default dataset location is next to /yolov5:
 4 | #   /parent_folder
 5 | #     /coco
 6 | #     /yolov5
 7 | 
 8 | 
 9 | # download command/URL (optional)
10 | download: bash data/scripts/get_coco.sh
11 | 
12 | # train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
13 | train: ../coco/train2017.txt  # 118287 images
14 | val: ../coco/val2017.txt  # 5000 images
15 | test: ../coco/test-dev2017.txt  # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
16 | 
17 | # number of classes
18 | nc: 80
19 | 
20 | # class names
21 | names: [ 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
22 |          'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
23 |          'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
24 |          'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
25 |          'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
26 |          'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
27 |          'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
28 |          'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear',
29 |          'hair drier', 'toothbrush' ]
30 | 
31 | # Print classes
32 | # with open('data/coco.yaml') as f:
33 | #   d = yaml.load(f, Loader=yaml.FullLoader)  # dict
34 | #   for i, x in enumerate(d['names']):
35 | #     print(i, x)
36 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | # Start FROM Nvidia PyTorch image https://ngc.nvidia.com/catalog/containers/nvidia:pytorch
 2 | FROM nvcr.io/nvidia/pytorch:21.02-py3
 3 | 
 4 | # Install linux packages
 5 | RUN apt update && apt install -y zip htop screen libgl1-mesa-glx
 6 | 
 7 | # Install python dependencies
 8 | COPY requirements.txt .
 9 | RUN python -m pip install --upgrade pip
10 | RUN pip install --no-cache -r requirements.txt gsutil notebook
11 | 
12 | # Create working directory
13 | RUN mkdir -p /usr/src/app
14 | WORKDIR /usr/src/app
15 | 
16 | # Copy contents
17 | COPY . /usr/src/app
18 | 
19 | # Set environment variables
20 | ENV HOME=/usr/src/app
21 | 
22 | 
23 | # ---------------------------------------------------  Extras Below  ---------------------------------------------------
24 | 
25 | # Build and Push
26 | # t=ultralytics/yolov5:latest && sudo docker build -t $t . && sudo docker push $t
27 | # for v in {300..303}; do t=ultralytics/coco:v$v && sudo docker build -t $t . && sudo docker push $t; done
28 | 
29 | # Pull and Run
30 | # t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all $t
31 | 
32 | # Pull and Run with local directory access
33 | # t=ultralytics/yolov5:latest && sudo docker pull $t && sudo docker run -it --ipc=host --gpus all -v "$(pwd)"/coco:/usr/src/coco $t
34 | 
35 | # Kill all
36 | # sudo docker kill $(sudo docker ps -q)
37 | 
38 | # Kill all image-based
39 | # sudo docker kill $(sudo docker ps -qa --filter ancestor=ultralytics/yolov5:latest)
40 | 
41 | # Bash into running container
42 | # sudo docker exec -it 5a9b5863d93d bash
43 | 
44 | # Bash into stopped container
45 | # id=$(sudo docker ps -qa) && sudo docker start $id && sudo docker exec -it $id bash
46 | 
47 | # Send weights to GCP
48 | # python -c "from utils.general import *; strip_optimizer('runs/train/exp0_*/weights/best.pt', 'tmp.pt')" && gsutil cp tmp.pt gs://*.pt
49 | 
50 | # Clean up
51 | # docker system prune -a --volumes
52 | 


--------------------------------------------------------------------------------
/models/hub/yolov5-p2.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors: 3
 8 | 
 9 | # YOLOv5 backbone
10 | backbone:
11 |   # [from, number, module, args]
12 |   [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
13 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
14 |     [ -1, 3, C3, [ 128 ] ],
15 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
16 |     [ -1, 9, C3, [ 256 ] ],
17 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
18 |     [ -1, 9, C3, [ 512 ] ],
19 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 7-P5/32
20 |     [ -1, 1, SPP, [ 1024, [ 5, 9, 13 ] ] ],
21 |     [ -1, 3, C3, [ 1024, False ] ],  # 9
22 |   ]
23 | 
24 | # YOLOv5 head
25 | head:
26 |   [ [ -1, 1, Conv, [ 512, 1, 1 ] ],
27 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
28 |     [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
29 |     [ -1, 3, C3, [ 512, False ] ],  # 13
30 | 
31 |     [ -1, 1, Conv, [ 256, 1, 1 ] ],
32 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
33 |     [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
34 |     [ -1, 3, C3, [ 256, False ] ],  # 17 (P3/8-small)
35 | 
36 |     [ -1, 1, Conv, [ 128, 1, 1 ] ],
37 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
38 |     [ [ -1, 2 ], 1, Concat, [ 1 ] ],  # cat backbone P2
39 |     [ -1, 1, C3, [ 128, False ] ],  # 21 (P2/4-xsmall)
40 | 
41 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],
42 |     [ [ -1, 18 ], 1, Concat, [ 1 ] ],  # cat head P3
43 |     [ -1, 3, C3, [ 256, False ] ],  # 24 (P3/8-small)
44 | 
45 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],
46 |     [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P4
47 |     [ -1, 3, C3, [ 512, False ] ],  # 27 (P4/16-medium)
48 | 
49 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],
50 |     [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat head P5
51 |     [ -1, 3, C3, [ 1024, False ] ],  # 30 (P5/32-large)
52 | 
53 |     [ [ 24, 27, 30 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5)
54 |   ]
55 | 


--------------------------------------------------------------------------------
/models/hub/yolov5-p6.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors: 3
 8 | 
 9 | # YOLOv5 backbone
10 | backbone:
11 |   # [from, number, module, args]
12 |   [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
13 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
14 |     [ -1, 3, C3, [ 128 ] ],
15 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
16 |     [ -1, 9, C3, [ 256 ] ],
17 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
18 |     [ -1, 9, C3, [ 512 ] ],
19 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],  # 7-P5/32
20 |     [ -1, 3, C3, [ 768 ] ],
21 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 9-P6/64
22 |     [ -1, 1, SPP, [ 1024, [ 3, 5, 7 ] ] ],
23 |     [ -1, 3, C3, [ 1024, False ] ],  # 11
24 |   ]
25 | 
26 | # YOLOv5 head
27 | head:
28 |   [ [ -1, 1, Conv, [ 768, 1, 1 ] ],
29 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
30 |     [ [ -1, 8 ], 1, Concat, [ 1 ] ],  # cat backbone P5
31 |     [ -1, 3, C3, [ 768, False ] ],  # 15
32 | 
33 |     [ -1, 1, Conv, [ 512, 1, 1 ] ],
34 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
35 |     [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
36 |     [ -1, 3, C3, [ 512, False ] ],  # 19
37 | 
38 |     [ -1, 1, Conv, [ 256, 1, 1 ] ],
39 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
40 |     [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
41 |     [ -1, 3, C3, [ 256, False ] ],  # 23 (P3/8-small)
42 | 
43 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],
44 |     [ [ -1, 20 ], 1, Concat, [ 1 ] ],  # cat head P4
45 |     [ -1, 3, C3, [ 512, False ] ],  # 26 (P4/16-medium)
46 | 
47 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],
48 |     [ [ -1, 16 ], 1, Concat, [ 1 ] ],  # cat head P5
49 |     [ -1, 3, C3, [ 768, False ] ],  # 29 (P5/32-large)
50 | 
51 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],
52 |     [ [ -1, 12 ], 1, Concat, [ 1 ] ],  # cat head P6
53 |     [ -1, 3, C3, [ 1024, False ] ],  # 32 (P5/64-xlarge)
54 | 
55 |     [ [ 23, 26, 29, 32 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5, P6)
56 |   ]
57 | 


--------------------------------------------------------------------------------
/models/hub/yolov5l6.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [ 19,27,  44,40,  38,94 ]  # P3/8
 9 |   - [ 96,68,  86,152,  180,137 ]  # P4/16
10 |   - [ 140,301,  303,264,  238,542 ]  # P5/32
11 |   - [ 436,615,  739,380,  925,792 ]  # P6/64
12 | 
13 | # YOLOv5 backbone
14 | backbone:
15 |   # [from, number, module, args]
16 |   [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
17 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
18 |     [ -1, 3, C3, [ 128 ] ],
19 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
20 |     [ -1, 9, C3, [ 256 ] ],
21 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
22 |     [ -1, 9, C3, [ 512 ] ],
23 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],  # 7-P5/32
24 |     [ -1, 3, C3, [ 768 ] ],
25 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 9-P6/64
26 |     [ -1, 1, SPP, [ 1024, [ 3, 5, 7 ] ] ],
27 |     [ -1, 3, C3, [ 1024, False ] ],  # 11
28 |   ]
29 | 
30 | # YOLOv5 head
31 | head:
32 |   [ [ -1, 1, Conv, [ 768, 1, 1 ] ],
33 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
34 |     [ [ -1, 8 ], 1, Concat, [ 1 ] ],  # cat backbone P5
35 |     [ -1, 3, C3, [ 768, False ] ],  # 15
36 | 
37 |     [ -1, 1, Conv, [ 512, 1, 1 ] ],
38 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
39 |     [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
40 |     [ -1, 3, C3, [ 512, False ] ],  # 19
41 | 
42 |     [ -1, 1, Conv, [ 256, 1, 1 ] ],
43 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
44 |     [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
45 |     [ -1, 3, C3, [ 256, False ] ],  # 23 (P3/8-small)
46 | 
47 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],
48 |     [ [ -1, 20 ], 1, Concat, [ 1 ] ],  # cat head P4
49 |     [ -1, 3, C3, [ 512, False ] ],  # 26 (P4/16-medium)
50 | 
51 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],
52 |     [ [ -1, 16 ], 1, Concat, [ 1 ] ],  # cat head P5
53 |     [ -1, 3, C3, [ 768, False ] ],  # 29 (P5/32-large)
54 | 
55 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],
56 |     [ [ -1, 12 ], 1, Concat, [ 1 ] ],  # cat head P6
57 |     [ -1, 3, C3, [ 1024, False ] ],  # 32 (P6/64-xlarge)
58 | 
59 |     [ [ 23, 26, 29, 32 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5, P6)
60 |   ]
61 | 


--------------------------------------------------------------------------------
/models/hub/yolov5m6.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 0.67  # model depth multiple
 4 | width_multiple: 0.75  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [ 19,27,  44,40,  38,94 ]  # P3/8
 9 |   - [ 96,68,  86,152,  180,137 ]  # P4/16
10 |   - [ 140,301,  303,264,  238,542 ]  # P5/32
11 |   - [ 436,615,  739,380,  925,792 ]  # P6/64
12 | 
13 | # YOLOv5 backbone
14 | backbone:
15 |   # [from, number, module, args]
16 |   [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
17 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
18 |     [ -1, 3, C3, [ 128 ] ],
19 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
20 |     [ -1, 9, C3, [ 256 ] ],
21 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
22 |     [ -1, 9, C3, [ 512 ] ],
23 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],  # 7-P5/32
24 |     [ -1, 3, C3, [ 768 ] ],
25 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 9-P6/64
26 |     [ -1, 1, SPP, [ 1024, [ 3, 5, 7 ] ] ],
27 |     [ -1, 3, C3, [ 1024, False ] ],  # 11
28 |   ]
29 | 
30 | # YOLOv5 head
31 | head:
32 |   [ [ -1, 1, Conv, [ 768, 1, 1 ] ],
33 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
34 |     [ [ -1, 8 ], 1, Concat, [ 1 ] ],  # cat backbone P5
35 |     [ -1, 3, C3, [ 768, False ] ],  # 15
36 | 
37 |     [ -1, 1, Conv, [ 512, 1, 1 ] ],
38 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
39 |     [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
40 |     [ -1, 3, C3, [ 512, False ] ],  # 19
41 | 
42 |     [ -1, 1, Conv, [ 256, 1, 1 ] ],
43 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
44 |     [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
45 |     [ -1, 3, C3, [ 256, False ] ],  # 23 (P3/8-small)
46 | 
47 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],
48 |     [ [ -1, 20 ], 1, Concat, [ 1 ] ],  # cat head P4
49 |     [ -1, 3, C3, [ 512, False ] ],  # 26 (P4/16-medium)
50 | 
51 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],
52 |     [ [ -1, 16 ], 1, Concat, [ 1 ] ],  # cat head P5
53 |     [ -1, 3, C3, [ 768, False ] ],  # 29 (P5/32-large)
54 | 
55 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],
56 |     [ [ -1, 12 ], 1, Concat, [ 1 ] ],  # cat head P6
57 |     [ -1, 3, C3, [ 1024, False ] ],  # 32 (P6/64-xlarge)
58 | 
59 |     [ [ 23, 26, 29, 32 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5, P6)
60 |   ]
61 | 


--------------------------------------------------------------------------------
/models/hub/yolov5s6.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 0.33  # model depth multiple
 4 | width_multiple: 0.50  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [ 19,27,  44,40,  38,94 ]  # P3/8
 9 |   - [ 96,68,  86,152,  180,137 ]  # P4/16
10 |   - [ 140,301,  303,264,  238,542 ]  # P5/32
11 |   - [ 436,615,  739,380,  925,792 ]  # P6/64
12 | 
13 | # YOLOv5 backbone
14 | backbone:
15 |   # [from, number, module, args]
16 |   [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
17 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
18 |     [ -1, 3, C3, [ 128 ] ],
19 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
20 |     [ -1, 9, C3, [ 256 ] ],
21 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
22 |     [ -1, 9, C3, [ 512 ] ],
23 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],  # 7-P5/32
24 |     [ -1, 3, C3, [ 768 ] ],
25 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 9-P6/64
26 |     [ -1, 1, SPP, [ 1024, [ 3, 5, 7 ] ] ],
27 |     [ -1, 3, C3, [ 1024, False ] ],  # 11
28 |   ]
29 | 
30 | # YOLOv5 head
31 | head:
32 |   [ [ -1, 1, Conv, [ 768, 1, 1 ] ],
33 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
34 |     [ [ -1, 8 ], 1, Concat, [ 1 ] ],  # cat backbone P5
35 |     [ -1, 3, C3, [ 768, False ] ],  # 15
36 | 
37 |     [ -1, 1, Conv, [ 512, 1, 1 ] ],
38 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
39 |     [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
40 |     [ -1, 3, C3, [ 512, False ] ],  # 19
41 | 
42 |     [ -1, 1, Conv, [ 256, 1, 1 ] ],
43 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
44 |     [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
45 |     [ -1, 3, C3, [ 256, False ] ],  # 23 (P3/8-small)
46 | 
47 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],
48 |     [ [ -1, 20 ], 1, Concat, [ 1 ] ],  # cat head P4
49 |     [ -1, 3, C3, [ 512, False ] ],  # 26 (P4/16-medium)
50 | 
51 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],
52 |     [ [ -1, 16 ], 1, Concat, [ 1 ] ],  # cat head P5
53 |     [ -1, 3, C3, [ 768, False ] ],  # 29 (P5/32-large)
54 | 
55 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],
56 |     [ [ -1, 12 ], 1, Concat, [ 1 ] ],  # cat head P6
57 |     [ -1, 3, C3, [ 1024, False ] ],  # 32 (P6/64-xlarge)
58 | 
59 |     [ [ 23, 26, 29, 32 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5, P6)
60 |   ]
61 | 


--------------------------------------------------------------------------------
/models/hub/yolov5x6.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.33  # model depth multiple
 4 | width_multiple: 1.25  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors:
 8 |   - [ 19,27,  44,40,  38,94 ]  # P3/8
 9 |   - [ 96,68,  86,152,  180,137 ]  # P4/16
10 |   - [ 140,301,  303,264,  238,542 ]  # P5/32
11 |   - [ 436,615,  739,380,  925,792 ]  # P6/64
12 | 
13 | # YOLOv5 backbone
14 | backbone:
15 |   # [from, number, module, args]
16 |   [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
17 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
18 |     [ -1, 3, C3, [ 128 ] ],
19 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
20 |     [ -1, 9, C3, [ 256 ] ],
21 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
22 |     [ -1, 9, C3, [ 512 ] ],
23 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],  # 7-P5/32
24 |     [ -1, 3, C3, [ 768 ] ],
25 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 9-P6/64
26 |     [ -1, 1, SPP, [ 1024, [ 3, 5, 7 ] ] ],
27 |     [ -1, 3, C3, [ 1024, False ] ],  # 11
28 |   ]
29 | 
30 | # YOLOv5 head
31 | head:
32 |   [ [ -1, 1, Conv, [ 768, 1, 1 ] ],
33 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
34 |     [ [ -1, 8 ], 1, Concat, [ 1 ] ],  # cat backbone P5
35 |     [ -1, 3, C3, [ 768, False ] ],  # 15
36 | 
37 |     [ -1, 1, Conv, [ 512, 1, 1 ] ],
38 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
39 |     [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
40 |     [ -1, 3, C3, [ 512, False ] ],  # 19
41 | 
42 |     [ -1, 1, Conv, [ 256, 1, 1 ] ],
43 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
44 |     [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
45 |     [ -1, 3, C3, [ 256, False ] ],  # 23 (P3/8-small)
46 | 
47 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],
48 |     [ [ -1, 20 ], 1, Concat, [ 1 ] ],  # cat head P4
49 |     [ -1, 3, C3, [ 512, False ] ],  # 26 (P4/16-medium)
50 | 
51 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],
52 |     [ [ -1, 16 ], 1, Concat, [ 1 ] ],  # cat head P5
53 |     [ -1, 3, C3, [ 768, False ] ],  # 29 (P5/32-large)
54 | 
55 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],
56 |     [ [ -1, 12 ], 1, Concat, [ 1 ] ],  # cat head P6
57 |     [ -1, 3, C3, [ 1024, False ] ],  # 32 (P6/64-xlarge)
58 | 
59 |     [ [ 23, 26, 29, 32 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5, P6)
60 |   ]
61 | 


--------------------------------------------------------------------------------
/models/hub/yolov5-p7.yaml:
--------------------------------------------------------------------------------
 1 | # parameters
 2 | nc: 80  # number of classes
 3 | depth_multiple: 1.0  # model depth multiple
 4 | width_multiple: 1.0  # layer channel multiple
 5 | 
 6 | # anchors
 7 | anchors: 3
 8 | 
 9 | # YOLOv5 backbone
10 | backbone:
11 |   # [from, number, module, args]
12 |   [ [ -1, 1, Focus, [ 64, 3 ] ],  # 0-P1/2
13 |     [ -1, 1, Conv, [ 128, 3, 2 ] ],  # 1-P2/4
14 |     [ -1, 3, C3, [ 128 ] ],
15 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],  # 3-P3/8
16 |     [ -1, 9, C3, [ 256 ] ],
17 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],  # 5-P4/16
18 |     [ -1, 9, C3, [ 512 ] ],
19 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],  # 7-P5/32
20 |     [ -1, 3, C3, [ 768 ] ],
21 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],  # 9-P6/64
22 |     [ -1, 3, C3, [ 1024 ] ],
23 |     [ -1, 1, Conv, [ 1280, 3, 2 ] ],  # 11-P7/128
24 |     [ -1, 1, SPP, [ 1280, [ 3, 5 ] ] ],
25 |     [ -1, 3, C3, [ 1280, False ] ],  # 13
26 |   ]
27 | 
28 | # YOLOv5 head
29 | head:
30 |   [ [ -1, 1, Conv, [ 1024, 1, 1 ] ],
31 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
32 |     [ [ -1, 10 ], 1, Concat, [ 1 ] ],  # cat backbone P6
33 |     [ -1, 3, C3, [ 1024, False ] ],  # 17
34 | 
35 |     [ -1, 1, Conv, [ 768, 1, 1 ] ],
36 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
37 |     [ [ -1, 8 ], 1, Concat, [ 1 ] ],  # cat backbone P5
38 |     [ -1, 3, C3, [ 768, False ] ],  # 21
39 | 
40 |     [ -1, 1, Conv, [ 512, 1, 1 ] ],
41 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
42 |     [ [ -1, 6 ], 1, Concat, [ 1 ] ],  # cat backbone P4
43 |     [ -1, 3, C3, [ 512, False ] ],  # 25
44 | 
45 |     [ -1, 1, Conv, [ 256, 1, 1 ] ],
46 |     [ -1, 1, nn.Upsample, [ None, 2, 'nearest' ] ],
47 |     [ [ -1, 4 ], 1, Concat, [ 1 ] ],  # cat backbone P3
48 |     [ -1, 3, C3, [ 256, False ] ],  # 29 (P3/8-small)
49 | 
50 |     [ -1, 1, Conv, [ 256, 3, 2 ] ],
51 |     [ [ -1, 26 ], 1, Concat, [ 1 ] ],  # cat head P4
52 |     [ -1, 3, C3, [ 512, False ] ],  # 32 (P4/16-medium)
53 | 
54 |     [ -1, 1, Conv, [ 512, 3, 2 ] ],
55 |     [ [ -1, 22 ], 1, Concat, [ 1 ] ],  # cat head P5
56 |     [ -1, 3, C3, [ 768, False ] ],  # 35 (P5/32-large)
57 | 
58 |     [ -1, 1, Conv, [ 768, 3, 2 ] ],
59 |     [ [ -1, 18 ], 1, Concat, [ 1 ] ],  # cat head P6
60 |     [ -1, 3, C3, [ 1024, False ] ],  # 38 (P6/64-xlarge)
61 | 
62 |     [ -1, 1, Conv, [ 1024, 3, 2 ] ],
63 |     [ [ -1, 14 ], 1, Concat, [ 1 ] ],  # cat head P7
64 |     [ -1, 3, C3, [ 1280, False ] ],  # 41 (P7/128-xxlarge)
65 | 
66 |     [ [ 29, 32, 35, 38, 41 ], 1, Detect, [ nc, anchors ] ],  # Detect(P3, P4, P5, P6, P7)
67 |   ]
68 | 


--------------------------------------------------------------------------------
/models/hub/anchors.yaml:
--------------------------------------------------------------------------------
 1 | # Default YOLOv5 anchors for COCO data
 2 | 
 3 | 
 4 | # P5 -------------------------------------------------------------------------------------------------------------------
 5 | # P5-640:
 6 | anchors_p5_640:
 7 |   - [ 10,13, 16,30, 33,23 ]  # P3/8
 8 |   - [ 30,61, 62,45, 59,119 ]  # P4/16
 9 |   - [ 116,90, 156,198, 373,326 ]  # P5/32
10 | 
11 | 
12 | # P6 -------------------------------------------------------------------------------------------------------------------
13 | # P6-640:  thr=0.25: 0.9964 BPR, 5.54 anchors past thr, n=12, img_size=640, metric_all=0.281/0.716-mean/best, past_thr=0.469-mean: 9,11,  21,19,  17,41,  43,32,  39,70,  86,64,  65,131,  134,130,  120,265,  282,180,  247,354,  512,387
14 | anchors_p6_640:
15 |   - [ 9,11,  21,19,  17,41 ]  # P3/8
16 |   - [ 43,32,  39,70,  86,64 ]  # P4/16
17 |   - [ 65,131,  134,130,  120,265 ]  # P5/32
18 |   - [ 282,180,  247,354,  512,387 ]  # P6/64
19 | 
20 | # P6-1280:  thr=0.25: 0.9950 BPR, 5.55 anchors past thr, n=12, img_size=1280, metric_all=0.281/0.714-mean/best, past_thr=0.468-mean: 19,27,  44,40,  38,94,  96,68,  86,152,  180,137,  140,301,  303,264,  238,542,  436,615,  739,380,  925,792
21 | anchors_p6_1280:
22 |   - [ 19,27,  44,40,  38,94 ]  # P3/8
23 |   - [ 96,68,  86,152,  180,137 ]  # P4/16
24 |   - [ 140,301,  303,264,  238,542 ]  # P5/32
25 |   - [ 436,615,  739,380,  925,792 ]  # P6/64
26 | 
27 | # P6-1920:  thr=0.25: 0.9950 BPR, 5.55 anchors past thr, n=12, img_size=1920, metric_all=0.281/0.714-mean/best, past_thr=0.468-mean: 28,41,  67,59,  57,141,  144,103,  129,227,  270,205,  209,452,  455,396,  358,812,  653,922,  1109,570,  1387,1187
28 | anchors_p6_1920:
29 |   - [ 28,41,  67,59,  57,141 ]  # P3/8
30 |   - [ 144,103,  129,227,  270,205 ]  # P4/16
31 |   - [ 209,452,  455,396,  358,812 ]  # P5/32
32 |   - [ 653,922,  1109,570,  1387,1187 ]  # P6/64
33 | 
34 | 
35 | # P7 -------------------------------------------------------------------------------------------------------------------
36 | # P7-640:  thr=0.25: 0.9962 BPR, 6.76 anchors past thr, n=15, img_size=640, metric_all=0.275/0.733-mean/best, past_thr=0.466-mean: 11,11,  13,30,  29,20,  30,46,  61,38,  39,92,  78,80,  146,66,  79,163,  149,150,  321,143,  157,303,  257,402,  359,290,  524,372
37 | anchors_p7_640:
38 |   - [ 11,11,  13,30,  29,20 ]  # P3/8
39 |   - [ 30,46,  61,38,  39,92 ]  # P4/16
40 |   - [ 78,80,  146,66,  79,163 ]  # P5/32
41 |   - [ 149,150,  321,143,  157,303 ]  # P6/64
42 |   - [ 257,402,  359,290,  524,372 ]  # P7/128
43 | 
44 | # P7-1280:  thr=0.25: 0.9968 BPR, 6.71 anchors past thr, n=15, img_size=1280, metric_all=0.273/0.732-mean/best, past_thr=0.463-mean: 19,22,  54,36,  32,77,  70,83,  138,71,  75,173,  165,159,  148,334,  375,151,  334,317,  251,626,  499,474,  750,326,  534,814,  1079,818
45 | anchors_p7_1280:
46 |   - [ 19,22,  54,36,  32,77 ]  # P3/8
47 |   - [ 70,83,  138,71,  75,173 ]  # P4/16
48 |   - [ 165,159,  148,334,  375,151 ]  # P5/32
49 |   - [ 334,317,  251,626,  499,474 ]  # P6/64
50 |   - [ 750,326,  534,814,  1079,818 ]  # P7/128
51 | 
52 | # P7-1920:  thr=0.25: 0.9968 BPR, 6.71 anchors past thr, n=15, img_size=1920, metric_all=0.273/0.732-mean/best, past_thr=0.463-mean: 29,34,  81,55,  47,115,  105,124,  207,107,  113,259,  247,238,  222,500,  563,227,  501,476,  376,939,  749,711,  1126,489,  801,1222,  1618,1227
53 | anchors_p7_1920:
54 |   - [ 29,34,  81,55,  47,115 ]  # P3/8
55 |   - [ 105,124,  207,107,  113,259 ]  # P4/16
56 |   - [ 247,238,  222,500,  563,227 ]  # P5/32
57 |   - [ 501,476,  376,939,  749,711 ]  # P6/64
58 |   - [ 1126,489,  801,1222,  1618,1227 ]  # P7/128
59 | 


--------------------------------------------------------------------------------
/models/export.py:
--------------------------------------------------------------------------------
  1 | """Exports a YOLOv5 *.pt model to ONNX and TorchScript formats
  2 | 
  3 | Usage:
  4 |     $ export PYTHONPATH="$PWD" && python models/export.py --weights ./weights/yolov5s.pt --img 640 --batch 1
  5 | """
  6 | 
  7 | import argparse
  8 | import sys
  9 | import time
 10 | 
 11 | sys.path.append('./')  # to run '$ python *.py' files in subdirectories
 12 | 
 13 | import torch
 14 | import torch.nn as nn
 15 | 
 16 | import models
 17 | from models.experimental import attempt_load
 18 | from utils.activations import Hardswish, SiLU
 19 | from utils.general import set_logging, check_img_size
 20 | from utils.torch_utils import select_device
 21 | 
 22 | if __name__ == '__main__':
 23 |     parser = argparse.ArgumentParser()
 24 |     parser.add_argument('--weights', type=str, default='./yolov5s.pt', help='weights path')  # from yolov5/models/
 25 |     parser.add_argument('--img-size', nargs='+', type=int, default=[640, 640], help='image size')  # height, width
 26 |     parser.add_argument('--batch-size', type=int, default=1, help='batch size')
 27 |     parser.add_argument('--dynamic', action='store_true', help='dynamic ONNX axes')
 28 |     parser.add_argument('--grid', action='store_true', help='export Detect() layer grid')
 29 |     parser.add_argument('--device', default='cpu', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
 30 |     opt = parser.parse_args()
 31 |     opt.img_size *= 2 if len(opt.img_size) == 1 else 1  # expand
 32 |     print(opt)
 33 |     set_logging()
 34 |     t = time.time()
 35 | 
 36 |     # Load PyTorch model
 37 |     device = select_device(opt.device)
 38 |     model = attempt_load(opt.weights, map_location=device)  # load FP32 model
 39 |     labels = model.names
 40 | 
 41 |     # Checks
 42 |     gs = int(max(model.stride))  # grid size (max stride)
 43 |     opt.img_size = [check_img_size(x, gs) for x in opt.img_size]  # verify img_size are gs-multiples
 44 | 
 45 |     # Input
 46 |     img = torch.zeros(opt.batch_size, 3, *opt.img_size).to(device)  # image size(1,3,320,192) iDetection
 47 | 
 48 |     # Update model
 49 |     for k, m in model.named_modules():
 50 |         m._non_persistent_buffers_set = set()  # pytorch 1.6.0 compatibility
 51 |         if isinstance(m, models.common.Conv):  # assign export-friendly activations
 52 |             if isinstance(m.act, nn.Hardswish):
 53 |                 m.act = Hardswish()
 54 |             elif isinstance(m.act, nn.SiLU):
 55 |                 m.act = SiLU()
 56 |         # elif isinstance(m, models.yolo.Detect):
 57 |         #     m.forward = m.forward_export  # assign forward (optional)
 58 |     model.model[-1].export = not opt.grid  # set Detect() layer grid export
 59 |     y = model(img)  # dry run
 60 | 
 61 |     # TorchScript export
 62 |     try:
 63 |         print('\nStarting TorchScript export with torch %s...' % torch.__version__)
 64 |         f = opt.weights.replace('.pt', '.torchscript.pt')  # filename
 65 |         ts = torch.jit.trace(model, img)
 66 |         ts.save(f)
 67 |         print('TorchScript export success, saved as %s' % f)
 68 |     except Exception as e:
 69 |         print('TorchScript export failure: %s' % e)
 70 | 
 71 |     # ONNX export
 72 |     try:
 73 |         import onnx
 74 | 
 75 |         print('\nStarting ONNX export with onnx %s...' % onnx.__version__)
 76 |         f = opt.weights.replace('.pt', '.onnx')  # filename
 77 |         torch.onnx.export(model, img, f, verbose=False, opset_version=12, input_names=['images'],
 78 |                           output_names=['classes', 'boxes'] if y is None else ['output'],
 79 |                           dynamic_axes={'images': {0: 'batch', 2: 'height', 3: 'width'},  # size(1,3,640,640)
 80 |                                         'output': {0: 'batch', 2: 'y', 3: 'x'}} if opt.dynamic else None)
 81 | 
 82 |         # Checks
 83 |         onnx_model = onnx.load(f)  # load onnx model
 84 |         onnx.checker.check_model(onnx_model)  # check onnx model
 85 |         # print(onnx.helper.printable_graph(onnx_model.graph))  # print a human readable model
 86 |         print('ONNX export success, saved as %s' % f)
 87 |     except Exception as e:
 88 |         print('ONNX export failure: %s' % e)
 89 | 
 90 |     # CoreML export
 91 |     try:
 92 |         import coremltools as ct
 93 | 
 94 |         print('\nStarting CoreML export with coremltools %s...' % ct.__version__)
 95 |         # convert model from torchscript and apply pixel scaling as per detect.py
 96 |         model = ct.convert(ts, inputs=[ct.ImageType(name='image', shape=img.shape, scale=1 / 255.0, bias=[0, 0, 0])])
 97 |         f = opt.weights.replace('.pt', '.mlmodel')  # filename
 98 |         model.save(f)
 99 |         print('CoreML export success, saved as %s' % f)
100 |     except Exception as e:
101 |         print('CoreML export failure: %s' % e)
102 | 
103 |     # Finish
104 |     print('\nExport complete (%.2fs). Visualize with https://github.com/lutzroeder/netron.' % (time.time() - t))
105 | 


--------------------------------------------------------------------------------
/data/scripts/get_voc.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC/
  3 | # Download command: bash data/scripts/get_voc.sh
  4 | # Train command: python train.py --data voc.yaml
  5 | # Default dataset location is next to /yolov5:
  6 | #   /parent_folder
  7 | #     /VOC
  8 | #     /yolov5
  9 | 
 10 | start=$(date +%s)
 11 | mkdir -p ../tmp
 12 | cd ../tmp/
 13 | 
 14 | # Download/unzip images and labels
 15 | d='.' # unzip directory
 16 | url=https://github.com/ultralytics/yolov5/releases/download/v1.0/
 17 | f1=VOCtrainval_06-Nov-2007.zip # 446MB, 5012 images
 18 | f2=VOCtest_06-Nov-2007.zip     # 438MB, 4953 images
 19 | f3=VOCtrainval_11-May-2012.zip # 1.95GB, 17126 images
 20 | for f in $f3 $f2 $f1; do
 21 |   echo 'Downloading' $url$f '...' 
 22 |   curl -L $url$f -o $f && unzip -q $f -d $d && rm $f & # download, unzip, remove in background
 23 | done
 24 | wait # finish background tasks
 25 | 
 26 | end=$(date +%s)
 27 | runtime=$((end - start))
 28 | echo "Completed in" $runtime "seconds"
 29 | 
 30 | echo "Splitting dataset..."
 31 | python3 - "$@" <<END
 32 | import xml.etree.ElementTree as ET
 33 | import pickle
 34 | import os
 35 | from os import listdir, getcwd
 36 | from os.path import join
 37 | 
 38 | sets=[('2012', 'train'), ('2012', 'val'), ('2007', 'train'), ('2007', 'val'), ('2007', 'test')]
 39 | 
 40 | classes = ["aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]
 41 | 
 42 | 
 43 | def convert(size, box):
 44 |     dw = 1./(size[0])
 45 |     dh = 1./(size[1])
 46 |     x = (box[0] + box[1])/2.0 - 1
 47 |     y = (box[2] + box[3])/2.0 - 1
 48 |     w = box[1] - box[0]
 49 |     h = box[3] - box[2]
 50 |     x = x*dw
 51 |     w = w*dw
 52 |     y = y*dh
 53 |     h = h*dh
 54 |     return (x,y,w,h)
 55 | 
 56 | def convert_annotation(year, image_id):
 57 |     in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id))
 58 |     out_file = open('VOCdevkit/VOC%s/labels/%s.txt'%(year, image_id), 'w')
 59 |     tree=ET.parse(in_file)
 60 |     root = tree.getroot()
 61 |     size = root.find('size')
 62 |     w = int(size.find('width').text)
 63 |     h = int(size.find('height').text)
 64 | 
 65 |     for obj in root.iter('object'):
 66 |         difficult = obj.find('difficult').text
 67 |         cls = obj.find('name').text
 68 |         if cls not in classes or int(difficult)==1:
 69 |             continue
 70 |         cls_id = classes.index(cls)
 71 |         xmlbox = obj.find('bndbox')
 72 |         b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text))
 73 |         bb = convert((w,h), b)
 74 |         out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
 75 | 
 76 | wd = getcwd()
 77 | 
 78 | for year, image_set in sets:
 79 |     if not os.path.exists('VOCdevkit/VOC%s/labels/'%(year)):
 80 |         os.makedirs('VOCdevkit/VOC%s/labels/'%(year))
 81 |     image_ids = open('VOCdevkit/VOC%s/ImageSets/Main/%s.txt'%(year, image_set)).read().strip().split()
 82 |     list_file = open('%s_%s.txt'%(year, image_set), 'w')
 83 |     for image_id in image_ids:
 84 |         list_file.write('%s/VOCdevkit/VOC%s/JPEGImages/%s.jpg\n'%(wd, year, image_id))
 85 |         convert_annotation(year, image_id)
 86 |     list_file.close()
 87 | 
 88 | END
 89 | 
 90 | cat 2007_train.txt 2007_val.txt 2012_train.txt 2012_val.txt >train.txt
 91 | cat 2007_train.txt 2007_val.txt 2007_test.txt 2012_train.txt 2012_val.txt >train.all.txt
 92 | 
 93 | python3 - "$@" <<END
 94 | 
 95 | import shutil
 96 | import os
 97 | os.system('mkdir ../VOC/')
 98 | os.system('mkdir ../VOC/images')
 99 | os.system('mkdir ../VOC/images/train')
100 | os.system('mkdir ../VOC/images/val')
101 | 
102 | os.system('mkdir ../VOC/labels')
103 | os.system('mkdir ../VOC/labels/train')
104 | os.system('mkdir ../VOC/labels/val')
105 | 
106 | import os
107 | print(os.path.exists('../tmp/train.txt'))
108 | f = open('../tmp/train.txt', 'r')
109 | lines = f.readlines()
110 | 
111 | for line in lines:
112 |     line = "/".join(line.split('/')[-5:]).strip()
113 |     if (os.path.exists("../" + line)):
114 |         os.system("cp ../"+ line + " ../VOC/images/train")
115 |         
116 |     line = line.replace('JPEGImages', 'labels')
117 |     line = line.replace('jpg', 'txt')
118 |     if (os.path.exists("../" + line)):
119 |         os.system("cp ../"+ line + " ../VOC/labels/train")
120 | 
121 | 
122 | print(os.path.exists('../tmp/2007_test.txt'))
123 | f = open('../tmp/2007_test.txt', 'r')
124 | lines = f.readlines()
125 | 
126 | for line in lines:
127 |     line = "/".join(line.split('/')[-5:]).strip()
128 |     if (os.path.exists("../" + line)):
129 |         os.system("cp ../"+ line + " ../VOC/images/val")
130 |         
131 |     line = line.replace('JPEGImages', 'labels')
132 |     line = line.replace('jpg', 'txt')
133 |     if (os.path.exists("../" + line)):
134 |         os.system("cp ../"+ line + " ../VOC/labels/val")
135 | 
136 | END
137 | 
138 | rm -rf ../tmp # remove temporary directory
139 | echo "VOC download done."
140 | 


--------------------------------------------------------------------------------
/models/experimental.py:
--------------------------------------------------------------------------------
  1 | # This file contains experimental modules
  2 | 
  3 | import numpy as np
  4 | import torch
  5 | import torch.nn as nn
  6 | 
  7 | from models.common import Conv, DWConv
  8 | from utils.google_utils import attempt_download
  9 | 
 10 | 
 11 | class CrossConv(nn.Module):
 12 |     # Cross Convolution Downsample
 13 |     def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
 14 |         # ch_in, ch_out, kernel, stride, groups, expansion, shortcut
 15 |         super(CrossConv, self).__init__()
 16 |         c_ = int(c2 * e)  # hidden channels
 17 |         self.cv1 = Conv(c1, c_, (1, k), (1, s))
 18 |         self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
 19 |         self.add = shortcut and c1 == c2
 20 | 
 21 |     def forward(self, x):
 22 |         return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
 23 | 
 24 | 
 25 | class Sum(nn.Module):
 26 |     # Weighted sum of 2 or more layers https://arxiv.org/abs/1911.09070
 27 |     def __init__(self, n, weight=False):  # n: number of inputs
 28 |         super(Sum, self).__init__()
 29 |         self.weight = weight  # apply weights boolean
 30 |         self.iter = range(n - 1)  # iter object
 31 |         if weight:
 32 |             self.w = nn.Parameter(-torch.arange(1., n) / 2, requires_grad=True)  # layer weights
 33 | 
 34 |     def forward(self, x):
 35 |         y = x[0]  # no weight
 36 |         if self.weight:
 37 |             w = torch.sigmoid(self.w) * 2
 38 |             for i in self.iter:
 39 |                 y = y + x[i + 1] * w[i]
 40 |         else:
 41 |             for i in self.iter:
 42 |                 y = y + x[i + 1]
 43 |         return y
 44 | 
 45 | 
 46 | class GhostConv(nn.Module):
 47 |     # Ghost Convolution https://github.com/huawei-noah/ghostnet
 48 |     def __init__(self, c1, c2, k=1, s=1, g=1, act=True):  # ch_in, ch_out, kernel, stride, groups
 49 |         super(GhostConv, self).__init__()
 50 |         c_ = c2 // 2  # hidden channels
 51 |         self.cv1 = Conv(c1, c_, k, s, None, g, act)
 52 |         self.cv2 = Conv(c_, c_, 5, 1, None, c_, act)
 53 | 
 54 |     def forward(self, x):
 55 |         y = self.cv1(x)
 56 |         return torch.cat([y, self.cv2(y)], 1)
 57 | 
 58 | 
 59 | class GhostBottleneck(nn.Module):
 60 |     # Ghost Bottleneck https://github.com/huawei-noah/ghostnet
 61 |     def __init__(self, c1, c2, k=3, s=1):  # ch_in, ch_out, kernel, stride
 62 |         super(GhostBottleneck, self).__init__()
 63 |         c_ = c2 // 2
 64 |         self.conv = nn.Sequential(GhostConv(c1, c_, 1, 1),  # pw
 65 |                                   DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(),  # dw
 66 |                                   GhostConv(c_, c2, 1, 1, act=False))  # pw-linear
 67 |         self.shortcut = nn.Sequential(DWConv(c1, c1, k, s, act=False),
 68 |                                       Conv(c1, c2, 1, 1, act=False)) if s == 2 else nn.Identity()
 69 | 
 70 |     def forward(self, x):
 71 |         return self.conv(x) + self.shortcut(x)
 72 | 
 73 | 
 74 | class MixConv2d(nn.Module):
 75 |     # Mixed Depthwise Conv https://arxiv.org/abs/1907.09595
 76 |     def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True):
 77 |         super(MixConv2d, self).__init__()
 78 |         groups = len(k)
 79 |         if equal_ch:  # equal c_ per group
 80 |             i = torch.linspace(0, groups - 1E-6, c2).floor()  # c2 indices
 81 |             c_ = [(i == g).sum() for g in range(groups)]  # intermediate channels
 82 |         else:  # equal weight.numel() per group
 83 |             b = [c2] + [0] * groups
 84 |             a = np.eye(groups + 1, groups, k=-1)
 85 |             a -= np.roll(a, 1, axis=1)
 86 |             a *= np.array(k) ** 2
 87 |             a[0] = 1
 88 |             c_ = np.linalg.lstsq(a, b, rcond=None)[0].round()  # solve for equal weight indices, ax = b
 89 | 
 90 |         self.m = nn.ModuleList([nn.Conv2d(c1, int(c_[g]), k[g], s, k[g] // 2, bias=False) for g in range(groups)])
 91 |         self.bn = nn.BatchNorm2d(c2)
 92 |         self.act = nn.LeakyReLU(0.1, inplace=True)
 93 | 
 94 |     def forward(self, x):
 95 |         return x + self.act(self.bn(torch.cat([m(x) for m in self.m], 1)))
 96 | 
 97 | 
 98 | class Ensemble(nn.ModuleList):
 99 |     # Ensemble of models
100 |     def __init__(self):
101 |         super(Ensemble, self).__init__()
102 | 
103 |     def forward(self, x, augment=False):
104 |         y = []
105 |         for module in self:
106 |             y.append(module(x, augment)[0])
107 |         # y = torch.stack(y).max(0)[0]  # max ensemble
108 |         # y = torch.stack(y).mean(0)  # mean ensemble
109 |         y = torch.cat(y, 1)  # nms ensemble
110 |         return y, None  # inference, train output
111 | 
112 | 
113 | def attempt_load(weights, map_location=None):
114 |     # Loads an ensemble of models weights=[a,b,c] or a single model weights=[a] or weights=a
115 |     model = Ensemble()
116 |     for w in weights if isinstance(weights, list) else [weights]:
117 |         attempt_download(w)
118 |         ckpt = torch.load(w, map_location=map_location)  # load
119 |         model.append(ckpt['ema' if ckpt.get('ema') else 'model'].float().fuse().eval())  # FP32 model
120 | 
121 |     # Compatibility updates
122 |     for m in model.modules():
123 |         if type(m) in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU]:
124 |             m.inplace = True  # pytorch 1.7.0 compatibility
125 |         elif type(m) is Conv:
126 |             m._non_persistent_buffers_set = set()  # pytorch 1.6.0 compatibility
127 | 
128 |     if len(model) == 1:
129 |         return model[-1]  # return model
130 |     else:
131 |         print('Ensemble created with %s\n' % weights)
132 |         for k in ['names', 'stride']:
133 |             setattr(model, k, getattr(model[-1], k))
134 |         return model  # return ensemble
135 | 


--------------------------------------------------------------------------------
/hubconf.py:
--------------------------------------------------------------------------------
  1 | """File for accessing YOLOv5 via PyTorch Hub https://pytorch.org/hub/
  2 | 
  3 | Usage:
  4 |     import torch
  5 |     model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True, channels=3, classes=80)
  6 | """
  7 | 
  8 | from pathlib import Path
  9 | 
 10 | import torch
 11 | 
 12 | from models.yolo import Model
 13 | from utils.general import set_logging
 14 | from utils.google_utils import attempt_download
 15 | 
 16 | dependencies = ['torch', 'yaml']
 17 | set_logging()
 18 | 
 19 | 
 20 | def create(name, pretrained, channels, classes, autoshape):
 21 |     """Creates a specified YOLOv5 model
 22 | 
 23 |     Arguments:
 24 |         name (str): name of model, i.e. 'yolov5s'
 25 |         pretrained (bool): load pretrained weights into the model
 26 |         channels (int): number of input channels
 27 |         classes (int): number of model classes
 28 | 
 29 |     Returns:
 30 |         pytorch model
 31 |     """
 32 |     config = Path(__file__).parent / 'models' / f'{name}.yaml'  # model.yaml path
 33 |     try:
 34 |         model = Model(config, channels, classes)
 35 |         if pretrained:
 36 |             fname = f'{name}.pt'  # checkpoint filename
 37 |             attempt_download(fname)  # download if not found locally
 38 |             ckpt = torch.load(fname, map_location=torch.device('cpu'))  # load
 39 |             state_dict = ckpt['model'].float().state_dict()  # to FP32
 40 |             state_dict = {k: v for k, v in state_dict.items() if model.state_dict()[k].shape == v.shape}  # filter
 41 |             model.load_state_dict(state_dict, strict=False)  # load
 42 |             if len(ckpt['model'].names) == classes:
 43 |                 model.names = ckpt['model'].names  # set class names attribute
 44 |             if autoshape:
 45 |                 model = model.autoshape()  # for file/URI/PIL/cv2/np inputs and NMS
 46 |         return model
 47 | 
 48 |     except Exception as e:
 49 |         help_url = 'https://github.com/ultralytics/yolov5/issues/36'
 50 |         s = 'Cache maybe be out of date, try force_reload=True. See %s for help.' % help_url
 51 |         raise Exception(s) from e
 52 | 
 53 | 
 54 | def yolov5s(pretrained=False, channels=3, classes=80, autoshape=True):
 55 |     """YOLOv5-small model from https://github.com/ultralytics/yolov5
 56 | 
 57 |     Arguments:
 58 |         pretrained (bool): load pretrained weights into the model, default=False
 59 |         channels (int): number of input channels, default=3
 60 |         classes (int): number of model classes, default=80
 61 | 
 62 |     Returns:
 63 |         pytorch model
 64 |     """
 65 |     return create('yolov5s', pretrained, channels, classes, autoshape)
 66 | 
 67 | 
 68 | def yolov5m(pretrained=False, channels=3, classes=80, autoshape=True):
 69 |     """YOLOv5-medium model from https://github.com/ultralytics/yolov5
 70 | 
 71 |     Arguments:
 72 |         pretrained (bool): load pretrained weights into the model, default=False
 73 |         channels (int): number of input channels, default=3
 74 |         classes (int): number of model classes, default=80
 75 | 
 76 |     Returns:
 77 |         pytorch model
 78 |     """
 79 |     return create('yolov5m', pretrained, channels, classes, autoshape)
 80 | 
 81 | 
 82 | def yolov5l(pretrained=False, channels=3, classes=80, autoshape=True):
 83 |     """YOLOv5-large model from https://github.com/ultralytics/yolov5
 84 | 
 85 |     Arguments:
 86 |         pretrained (bool): load pretrained weights into the model, default=False
 87 |         channels (int): number of input channels, default=3
 88 |         classes (int): number of model classes, default=80
 89 | 
 90 |     Returns:
 91 |         pytorch model
 92 |     """
 93 |     return create('yolov5l', pretrained, channels, classes, autoshape)
 94 | 
 95 | 
 96 | def yolov5x(pretrained=False, channels=3, classes=80, autoshape=True):
 97 |     """YOLOv5-xlarge model from https://github.com/ultralytics/yolov5
 98 | 
 99 |     Arguments:
100 |         pretrained (bool): load pretrained weights into the model, default=False
101 |         channels (int): number of input channels, default=3
102 |         classes (int): number of model classes, default=80
103 | 
104 |     Returns:
105 |         pytorch model
106 |     """
107 |     return create('yolov5x', pretrained, channels, classes, autoshape)
108 | 
109 | 
110 | def custom(path_or_model='path/to/model.pt', autoshape=True):
111 |     """YOLOv5-custom model from https://github.com/ultralytics/yolov5
112 | 
113 |     Arguments (3 options):
114 |         path_or_model (str): 'path/to/model.pt'
115 |         path_or_model (dict): torch.load('path/to/model.pt')
116 |         path_or_model (nn.Module): torch.load('path/to/model.pt')['model']
117 | 
118 |     Returns:
119 |         pytorch model
120 |     """
121 |     model = torch.load(path_or_model) if isinstance(path_or_model, str) else path_or_model  # load checkpoint
122 |     if isinstance(model, dict):
123 |         model = model['ema' if model.get('ema') else 'model']  # load model
124 | 
125 |     hub_model = Model(model.yaml).to(next(model.parameters()).device)  # create
126 |     hub_model.load_state_dict(model.float().state_dict())  # load state_dict
127 |     hub_model.names = model.names  # class names
128 |     return hub_model.autoshape() if autoshape else hub_model
129 | 
130 | 
131 | if __name__ == '__main__':
132 |     model = create(name='yolov5s', pretrained=True, channels=3, classes=80, autoshape=True)  # pretrained example
133 |     # model = custom(path_or_model='path/to/model.pt')  # custom example
134 | 
135 |     # Verify inference
136 |     import numpy as np
137 |     from PIL import Image
138 | 
139 |     imgs = [Image.open('data/images/bus.jpg'),  # PIL
140 |             'data/images/zidane.jpg',  # filename
141 |             'https://github.com/ultralytics/yolov5/raw/master/data/images/bus.jpg',  # URI
142 |             np.zeros((640, 480, 3))]  # numpy
143 | 
144 |     results = model(imgs)  # batched inference
145 |     results.print()
146 |     results.save()
147 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Python-Yolov5-Detection-and-recognition-of-emotion-expression
 2 | 🔥🔥🔥Python+Yolov5面部情感表情检测识别Detection and recognition of emotion and expression
 3 | 
 4 | >**Python+Yolov5面部情感表情检测识别**  
 5 | >**如需安装运行环境或远程调试，见文章底部名片(或直接加QQ:2945218359)，由专业技术人员远程协助！**  
 6 | 
 7 | 
 8 | 
 9 | ## 运行环境
10 | **编程语言：Python3**  
11 | **依赖库：torch**  
12 | 
13 | ## 运行效果
14 | <img src="https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/blob/main/screenshot/3.jpg" width="500"></a>
15 | <img src="https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/blob/main/screenshot/1.jpeg" width="500"></a>
16 | <img src="https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression/blob/main/screenshot/2.png" width="500"></a>
17 | 
18 | 
19 | ## 在线协助
20 | **如需安装运行环境或远程调试，可扫码或直接加QQ:2945218359, QQ:905733049由专业技术人员远程协助！**  
21 | **1）远程安装运行环境，代码调试**  
22 | **2）Qt, C++, Python入门指导**  
23 | **3）界面美化**  
24 | **4）软件制作**  
25 | **5）云服务器申请**  
26 | **6）网站制作**  
27 | 
28 | **扫码或**<a href="https://img-blog.csdnimg.cn/132d32981a6d4d48bdf578f9810bd341.png" target="_blank">**点这里**</a>**(QQ:2945218359, QQ:905733049)**  
29 | <a href="https://img-blog.csdnimg.cn/132d32981a6d4d48bdf578f9810bd341.png" target="_blank">
30 |   <img src="https://github.com/alicema-creator/Python-Yolov8-Statistics-of-the-number-of-people-at-the-entrance-and-exit/blob/main/screenshot/qrcode.png" width="200">
31 |   <img src="https://github.com/alicema-creator/Python-Yolov8-Statistics-of-the-number-of-people-at-the-entrance-and-exit/blob/main/screenshot/qrcode2.png" width="200">
32 | </a>
33 | 
34 | 
35 | <font color=#000000 size=4>**🏠作者推荐：**</font>  
36 | <font color=#000000 size=4>
37 | <font color=#000000 size=4>**🌟Python特征识别检测项目🌟**</font>  
38 | 
39 | **Python+Yolov5表情检测识别：**
40 | [https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression](https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression)  
41 | **Python指纹识别系统：**
42 | [https://github.com/alicema-creator/Python-fingerprint-recogn-system](https://github.com/alicema-creator/Python-fingerprint-recogn-system)  
43 | **Python人脸识别考勤打卡系统2：**
44 | [https://github.com/alicema-creator/Python-OpenCV-Face-recognition-attendance-management-system2](https://github.com/alicema-creator/Python-OpenCV-Face-recognition-attendance-management-system2)  
45 | **Python人脸识别考勤打卡系统：**
46 | [https://github.com/alicema-creator/Python-OpenCV-Face-recognition-attendance-management-system](https://github.com/alicema-creator/Python-OpenCV-Face-recognition-attendance-management-system)  
47 |  **Python果树水果识别**：[https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-apple-fruit](https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-apple-fruit)  
48 | **Python+Yolov8+Deepsort入口人流量统计：**[https://github.com/alicema-creator/Python-Yolov8-Statistics-of-the-number-of-people-at-the-entrance-and-exit](https://github.com/alicema-creator/Python-Yolov8-Statistics-of-the-number-of-people-at-the-entrance-and-exit)  
49 | **Python+Qt指纹录入识别考勤系统：**[https://blog.csdn.net/alicema1111/article/details/129338432](https://blog.csdn.net/alicema1111/article/details/129338432)  
50 | **Python手势特征识别：**[https://github.com/alicema-creator/Python-Yolov8-gesture-recognition](https://github.com/alicema-creator/Python-Yolov8-gesture-recognition)  
51 | **Python+Yolov5路面桥梁墙体裂缝识别：**[https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-cracks-in-road-bridges](https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-cracks-in-road-bridges)  
52 | **Python+Yolov8路面桥梁墙体裂缝识别：**[https://github.com/alicema-creator/Python-Yolov8-crack-recognition-for-road-bridge-wall](https://github.com/alicema-creator/Python-Yolov8-crack-recognition-for-road-bridge-wall)  
53 | **Python+Qt人行道盲道特征检测识别窗体程序：**[https://github.com/alicema-creator/Python-Qt-Detection-and-recognition-of-sidewalk-tactile-paving](https://github.com/alicema-creator/Python-Qt-Detection-and-recognition-of-sidewalk-tactile-paving)  
54 | **Python+Yolov5面部情感表情检测识别：**[https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression](https://github.com/alicema-creator/Python-Yolov5-Detection-and-recognition-of-emotion-expression)  
55 | 
56 | 
57 | <font color=#000000 size=4></font>  
58 | <font color=#000000 size=4>**🌟Python/Django网页项目🌟**</font>  
59 | **Python+Django+HTMLl网页前后端指纹信息识别：**[https://github.com/alicema-creator/Python-Django-HTML-web-fingerprint-information-recognition](https://github.com/alicema-creator/Python-Django-HTML-web-fingerprint-information-recognition)  
60 | **Html+threejs网页数字孪生场景三维可视化：**[https://github.com/alicema-creator/html-threejs-twin-scenes-3D-visualization-project](https://github.com/alicema-creator/html-threejs-twin-scenes-3D-visualization-project)  
61 | **python+django+html药物管理系统web drug management system(crm)：**[https://github.com/alicema-creator/python-django-web-html-drug-management-system](https://github.com/alicema-creator/python-django-web-html-drug-management-system)  
62 | **Qt+C++ web browser自建网页浏览器-Chrome最新内核基础上搭建：**[https://github.com/alicema-creator/Qt-and-C-web-browser--Chrome-latest-kernel](https://github.com/alicema-creator/Qt-and-C-web-browser--Chrome-latest-kernel)  
63 | 
64 | 
65 | <font color=#000000 size=4></font>  
66 | <font color=#000000 size=4>**🌟C++/Qt项目🌟**</font>  
67 | **OCC Opencascade+Qt+C++三维图像建模窗体点线面拾取：**[https://github.com/alicema-creator/OCC-Opencascade-Qt-C-3D-model-modeling-point-line-surface-pick-igs-iges-stp-step](https://github.com/alicema-creator/OCC-Opencascade-Qt-C-3D-model-modeling-point-line-surface-pick-igs-iges-stp-step)  
68 | **Qt+VTK鼠标拾取点生成拉伸闭合三维体：**[https://github.com/alicema-creator/Qt-VTK-mouse-picking-points-to-generate-extruded-closed-3D-volumes](https://github.com/alicema-creator/Qt-VTK-mouse-picking-points-to-generate-extruded-closed-3D-volumes)  
69 | **Qt+C++实现的串口通信工具带实时曲线图：**[https://github.com/alicema-creator/Qt-VTK-mouse-picking-points-to-generate-extruded-closed-3D-volumes]([https://github.com/alicema-creator/SerialPort-Communication)](https://github.com/alicema-creator/Qt-VTK-mouse-picking-points-to-generate-extruded-closed-3D-volumes](https://github.com/alicema-creator/SerialPort-Communication))  
70 | 
71 | </font>  
72 | 


--------------------------------------------------------------------------------
/detect_camera.py:
--------------------------------------------------------------------------------
  1 | import argparse
  2 | import time
  3 | from pathlib import Path
  4 | 
  5 | import cv2
  6 | import torch
  7 | import torch.backends.cudnn as cudnn
  8 | from numpy import random
  9 | 
 10 | from models.experimental import attempt_load
 11 | from utils.datasets import LoadStreams, LoadImages
 12 | from utils.general import check_img_size, check_requirements, check_imshow, non_max_suppression, apply_classifier, \
 13 |     scale_coords, xyxy2xywh, strip_optimizer, set_logging, increment_path
 14 | from utils.plots import plot_one_box
 15 | from utils.torch_utils import select_device, load_classifier, time_synchronized
 16 | 
 17 | 
 18 | def detect(save_img=False):
 19 |     source, weights, view_img, save_txt, imgsz = opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
 20 |     webcam = source.isnumeric() or source.endswith('.txt') or source.lower().startswith(
 21 |         ('rtsp://', 'rtmp://', 'http://'))
 22 | 
 23 |     # Directories
 24 |     save_dir = Path(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok))  # increment run
 25 |     (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True)  # make dir
 26 | 
 27 |     # Initialize
 28 |     set_logging()
 29 |     device = select_device(opt.device)
 30 |     half = device.type != 'cpu'  # half precision only supported on CUDA
 31 | 
 32 |     # Load model
 33 |     model = attempt_load(weights, map_location=device)  # load FP32 model
 34 |     stride = int(model.stride.max())  # model stride
 35 |     imgsz = check_img_size(imgsz, s=stride)  # check img_size
 36 |     if half:
 37 |         model.half()  # to FP16
 38 | 
 39 |     # Second-stage classifier
 40 |     classify = False
 41 |     if classify:
 42 |         modelc = load_classifier(name='resnet101', n=2)  # initialize
 43 |         modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model']).to(device).eval()
 44 | 
 45 |     # Set Dataloader
 46 |     vid_path, vid_writer = None, None
 47 |     if webcam:
 48 |         view_img = check_imshow()
 49 |         cudnn.benchmark = True  # set True to speed up constant image size inference
 50 |         dataset = LoadStreams(source, img_size=imgsz, stride=stride)
 51 |     else:
 52 |         save_img = True
 53 |         dataset = LoadImages(source, img_size=imgsz, stride=stride)
 54 | 
 55 |     # Get names and colors
 56 |     names = model.module.names if hasattr(model, 'module') else model.names
 57 |     colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
 58 | 
 59 |     # Run inference
 60 |     if device.type != 'cpu':
 61 |         model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))  # run once
 62 |     t0 = time.time()
 63 |     for path, img, im0s, vid_cap in dataset:
 64 |         img = torch.from_numpy(img).to(device)
 65 |         img = img.half() if half else img.float()  # uint8 to fp16/32
 66 |         img /= 255.0  # 0 - 255 to 0.0 - 1.0
 67 |         if img.ndimension() == 3:
 68 |             img = img.unsqueeze(0)
 69 | 
 70 |         # Inference
 71 |         t1 = time_synchronized()
 72 |         pred = model(img, augment=opt.augment)[0]
 73 | 
 74 |         # Apply NMS
 75 |         pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)
 76 |         t2 = time_synchronized()
 77 | 
 78 |         # Apply Classifier
 79 |         if classify:
 80 |             pred = apply_classifier(pred, modelc, img, im0s)
 81 | 
 82 |         # Process detections
 83 |         for i, det in enumerate(pred):  # detections per image
 84 |             if webcam:  # batch_size >= 1
 85 |                 p, s, im0, frame = path[i], '%g: ' % i, im0s[i].copy(), dataset.count
 86 |             else:
 87 |                 p, s, im0, frame = path, '', im0s, getattr(dataset, 'frame', 0)
 88 | 
 89 |             p = Path(p)  # to Path
 90 |             save_path = str(save_dir / p.name)  # img.jpg
 91 |             txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}')  # img.txt
 92 |             s += '%gx%g ' % img.shape[2:]  # print string
 93 |             gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]  # normalization gain whwh
 94 |             if len(det):
 95 |                 # Rescale boxes from img_size to im0 size
 96 |                 det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
 97 | 
 98 |                 # Print results
 99 | 
100 |                 for c in det[:, -1].unique():
101 |                     n = (det[:, -1] == c).sum()  # detections per class
102 |                     s += f"{n} {names[int(c)]}{'s' * (n > 1)}, "  # add to string
103 | 
104 | 
105 | 
106 |                 # Write results
107 |                 for *xyxy, conf, cls in reversed(det):
108 |                     if save_txt:  # Write to file
109 |                         xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()  # normalized xywh
110 |                         line = (cls, *xywh, conf) if opt.save_conf else (cls, *xywh)  # label format
111 |                         with open(txt_path + '.txt', 'a') as f:
112 |                             f.write(('%g ' * len(line)).rstrip() % line + '\n')
113 | 
114 |                     if save_img or view_img:  # Add bbox to image
115 |                         label = f'{names[int(cls)]} {conf:.2f}'
116 |                         plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3)
117 | 
118 |             # Print time (inference + NMS)
119 |             print(f'{s}Done. ({t2 - t1:.3f}s)')
120 | 
121 |             # Stream results
122 |             if view_img:
123 |                 cv2.imshow(str(p), im0)
124 |                 cv2.waitKey(1)  # 1 millisecond
125 | 
126 |             # Save results (image with detections)
127 |             if save_img:
128 |                 if dataset.mode == 'image':
129 |                     cv2.imwrite(save_path, im0)
130 |                 else:  # 'video'
131 |                     if vid_path != save_path:  # new video
132 |                         vid_path = save_path
133 |                         if isinstance(vid_writer, cv2.VideoWriter):
134 |                             vid_writer.release()  # release previous video writer
135 | 
136 |                         fourcc = 'mp4v'  # output video codec
137 |                         fps = vid_cap.get(cv2.CAP_PROP_FPS)
138 |                         w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
139 |                         h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
140 |                         vid_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*fourcc), fps, (w, h))
141 |                     vid_writer.write(im0)
142 | 
143 |     if save_txt or save_img:
144 |         s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
145 |         print(f"Results saved to {save_dir}{s}")
146 | 
147 |     print(f'Done. ({time.time() - t0:.3f}s)')
148 | 
149 | 
150 | if __name__ == '__main__':
151 |     parser = argparse.ArgumentParser()
152 |     parser.add_argument('--weights', nargs='+', type=str, default='yolov5s.pt', help='model.pt path(s)')
153 |     parser.add_argument('--source', type=str, default='0', help='source')  # file/folder, 0 for webcam
154 |     parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
155 |     parser.add_argument('--conf-thres', type=float, default=0.25, help='object confidence threshold')
156 |     parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
157 |     parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
158 |     parser.add_argument('--view-img', action='store_true', help='display results')
159 |     parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
160 |     parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
161 |     parser.add_argument('--classes', nargs='+', type=int, default='0', help='filter by class: --class 0, or --class 0 2 3')
162 |     parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
163 |     parser.add_argument('--augment', action='store_true', help='augmented inference')
164 |     parser.add_argument('--update', action='store_true', help='update all models')
165 |     parser.add_argument('--project', default='runs/detect', help='save results to project/name')
166 |     parser.add_argument('--name', default='exp', help='save results to project/name')
167 |     parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
168 |     opt = parser.parse_args()
169 |     
170 |     print(opt)
171 |     #check_requirements()
172 | 
173 |     with torch.no_grad():
174 |         if opt.update:  # update all models (to fix SourceChangeWarning)
175 |             for opt.weights in ['yolov5s.pt', 'yolov5m.pt', 'yolov5l.pt', 'yolov5x.pt']:
176 |                 detect()
177 |                 strip_optimizer(opt.weights)
178 |         else:
179 |             detect()
180 | 


--------------------------------------------------------------------------------
/detect_photo.py:
--------------------------------------------------------------------------------
  1 | import argparse
  2 | import time
  3 | from pathlib import Path
  4 | 
  5 | import cv2
  6 | import torch
  7 | import torch.backends.cudnn as cudnn
  8 | from numpy import random
  9 | 
 10 | from models.experimental import attempt_load
 11 | from utils.datasets import LoadStreams, LoadImages
 12 | from utils.general import check_img_size, check_requirements, check_imshow, non_max_suppression, apply_classifier, \
 13 |     scale_coords, xyxy2xywh, strip_optimizer, set_logging, increment_path
 14 | from utils.plots import plot_one_box
 15 | from utils.torch_utils import select_device, load_classifier, time_synchronized
 16 | 
 17 | 
 18 | def detect(save_img=False):
 19 |     source, weights, view_img, save_txt, imgsz = opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
 20 |     webcam = source.isnumeric() or source.endswith('.txt') or source.lower().startswith(
 21 |         ('rtsp://', 'rtmp://', 'http://'))
 22 | 
 23 |     # Directories
 24 |     save_dir = Path(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok))  # increment run
 25 |     (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True)  # make dir
 26 | 
 27 |     # Initialize
 28 |     set_logging()
 29 |     device = select_device(opt.device)
 30 |     half = device.type != 'cpu'  # half precision only supported on CUDA
 31 | 
 32 |     # Load model
 33 |     model = attempt_load(weights, map_location=device)  # load FP32 model
 34 |     stride = int(model.stride.max())  # model stride
 35 |     imgsz = check_img_size(imgsz, s=stride)  # check img_size
 36 |     if half:
 37 |         model.half()  # to FP16
 38 | 
 39 |     # Second-stage classifier
 40 |     classify = False
 41 |     if classify:
 42 |         modelc = load_classifier(name='resnet101', n=2)  # initialize
 43 |         modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model']).to(device).eval()
 44 | 
 45 |     # Set Dataloader
 46 |     vid_path, vid_writer = None, None
 47 |     if webcam:
 48 |         view_img = check_imshow()
 49 |         cudnn.benchmark = True  # set True to speed up constant image size inference
 50 |         dataset = LoadStreams(source, img_size=imgsz, stride=stride)
 51 |     else:
 52 |         save_img = True
 53 |         dataset = LoadImages(source, img_size=imgsz, stride=stride)
 54 | 
 55 |     # Get names and colors
 56 |     names = model.module.names if hasattr(model, 'module') else model.names
 57 |     colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
 58 | 
 59 |     # Run inference
 60 |     if device.type != 'cpu':
 61 |         model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))  # run once
 62 |     t0 = time.time()
 63 |     for path, img, im0s, vid_cap in dataset:
 64 |         img = torch.from_numpy(img).to(device)
 65 |         img = img.half() if half else img.float()  # uint8 to fp16/32
 66 |         img /= 255.0  # 0 - 255 to 0.0 - 1.0
 67 |         if img.ndimension() == 3:
 68 |             img = img.unsqueeze(0)
 69 | 
 70 |         # Inference
 71 |         t1 = time_synchronized()
 72 |         pred = model(img, augment=opt.augment)[0]
 73 | 
 74 |         # Apply NMS
 75 |         pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)
 76 |         t2 = time_synchronized()
 77 | 
 78 |         # Apply Classifier
 79 |         if classify:
 80 |             pred = apply_classifier(pred, modelc, img, im0s)
 81 | 
 82 |         # Process detections
 83 |         for i, det in enumerate(pred):  # detections per image
 84 |             if webcam:  # batch_size >= 1
 85 |                 p, s, im0, frame = path[i], '%g: ' % i, im0s[i].copy(), dataset.count
 86 |             else:
 87 |                 p, s, im0, frame = path, '', im0s, getattr(dataset, 'frame', 0)
 88 | 
 89 |             p = Path(p)  # to Path
 90 |             save_path = str(save_dir / p.name)  # img.jpg
 91 |             txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}')  # img.txt
 92 |             s += '%gx%g ' % img.shape[2:]  # print string
 93 |             gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]  # normalization gain whwh
 94 |             if len(det):
 95 |                 # Rescale boxes from img_size to im0 size
 96 |                 det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
 97 | 
 98 |                 # Print results
 99 | 
100 |                 for c in det[:, -1].unique():
101 |                     n = (det[:, -1] == c).sum()  # detections per class
102 |                     s += f"{n} {names[int(c)]}{'s' * (n > 1)}, "  # add to string
103 | 
104 |   
105 | 
106 |                 # Write results
107 |                 for *xyxy, conf, cls in reversed(det):
108 |                     if save_txt:  # Write to file
109 |                         xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()  # normalized xywh
110 |                         line = (cls, *xywh, conf) if opt.save_conf else (cls, *xywh)  # label format
111 |                         with open(txt_path + '.txt', 'a') as f:
112 |                             f.write(('%g ' * len(line)).rstrip() % line + '\n')
113 | 
114 |                     if save_img or view_img:  # Add bbox to image
115 |                         label = f'{names[int(cls)]} {conf:.2f}'
116 |                         plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3)
117 | 
118 |             # Print time (inference + NMS)
119 |             print(f'{s}Done. ({t2 - t1:.3f}s)')
120 | 
121 |             # Stream results
122 |             if view_img:
123 |                 cv2.imshow(str(p), im0)
124 |                 cv2.waitKey(1)  # 1 millisecond
125 | 
126 |             # Save results (image with detections)
127 |             if save_img:
128 |                 if dataset.mode == 'image':
129 |                     cv2.imwrite(save_path, im0)
130 |                 else:  # 'video'
131 |                     if vid_path != save_path:  # new video
132 |                         vid_path = save_path
133 |                         if isinstance(vid_writer, cv2.VideoWriter):
134 |                             vid_writer.release()  # release previous video writer
135 | 
136 |                         fourcc = 'mp4v'  # output video codec
137 |                         fps = vid_cap.get(cv2.CAP_PROP_FPS)
138 |                         w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
139 |                         h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
140 |                         vid_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*fourcc), fps, (w, h))
141 |                     vid_writer.write(im0)
142 | 
143 |     if save_txt or save_img:
144 |         s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
145 |         print(f"Results saved to {save_dir}{s}")
146 | 
147 |     print(f'Done. ({time.time() - t0:.3f}s)')
148 | 
149 | 
150 | if __name__ == '__main__':
151 |     parser = argparse.ArgumentParser()
152 |     parser.add_argument('--weights', nargs='+', type=str, default='yolov5s.pt', help='model.pt path(s)')
153 |     parser.add_argument('--source', type=str, default='data/images', help='source')  # file/folder, 0 for webcam
154 |     parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
155 |     parser.add_argument('--conf-thres', type=float, default=0.4, help='object confidence threshold')
156 |     parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
157 |     parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
158 |     parser.add_argument('--view-img', action='store_true', help='display results')
159 |     parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
160 |     parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
161 |     parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
162 |     parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
163 |     parser.add_argument('--augment', action='store_true', help='augmented inference')
164 |     parser.add_argument('--update', action='store_true', help='update all models')
165 |     parser.add_argument('--project', default='runs/detect', help='save results to project/name')
166 |     parser.add_argument('--name', default='exp', help='save results to project/name')
167 |     parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
168 |     opt = parser.parse_args()
169 |     
170 |     print(opt)
171 |     #check_requirements()
172 | 
173 |     with torch.no_grad():
174 |         if opt.update:  # update all models (to fix SourceChangeWarning)
175 |             for opt.weights in ['yolov5s.pt', 'yolov5m.pt', 'yolov5l.pt', 'yolov5x.pt']:
176 |                 detect()
177 |                 strip_optimizer(opt.weights)
178 |         else:
179 |             detect()
180 | 


--------------------------------------------------------------------------------
/models/yolo.py:
--------------------------------------------------------------------------------
  1 | import argparse
  2 | import logging
  3 | import sys
  4 | from copy import deepcopy
  5 | 
  6 | sys.path.append('./')  # to run '$ python *.py' files in subdirectories
  7 | logger = logging.getLogger(__name__)
  8 | 
  9 | from models.common import *
 10 | from models.experimental import *
 11 | from utils.autoanchor import check_anchor_order
 12 | from utils.general import make_divisible, check_file, set_logging
 13 | from utils.torch_utils import time_synchronized, fuse_conv_and_bn, model_info, scale_img, initialize_weights, \
 14 |     select_device, copy_attr
 15 | 
 16 | try:
 17 |     import thop  # for FLOPS computation
 18 | except ImportError:
 19 |     thop = None
 20 | 
 21 | 
 22 | class Detect(nn.Module):
 23 |     stride = None  # strides computed during build
 24 |     export = False  # onnx export
 25 | 
 26 |     def __init__(self, nc=80, anchors=(), ch=()):  # detection layer
 27 |         super(Detect, self).__init__()
 28 |         self.nc = nc  # number of classes
 29 |         self.no = nc + 5  # number of outputs per anchor
 30 |         self.nl = len(anchors)  # number of detection layers
 31 |         self.na = len(anchors[0]) // 2  # number of anchors
 32 |         self.grid = [torch.zeros(1)] * self.nl  # init grid
 33 |         a = torch.tensor(anchors).float().view(self.nl, -1, 2)
 34 |         self.register_buffer('anchors', a)  # shape(nl,na,2)
 35 |         self.register_buffer('anchor_grid', a.clone().view(self.nl, 1, -1, 1, 1, 2))  # shape(nl,1,na,1,1,2)
 36 |         self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch)  # output conv
 37 | 
 38 |     def forward(self, x):
 39 |         # x = x.copy()  # for profiling
 40 |         z = []  # inference output
 41 |         self.training |= self.export
 42 |         for i in range(self.nl):
 43 |             x[i] = self.m[i](x[i])  # conv
 44 |             bs, _, ny, nx = x[i].shape  # x(bs,255,20,20) to x(bs,3,20,20,85)
 45 |             x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
 46 | 
 47 |             if not self.training:  # inference
 48 |                 if self.grid[i].shape[2:4] != x[i].shape[2:4]:
 49 |                     self.grid[i] = self._make_grid(nx, ny).to(x[i].device)
 50 | 
 51 |                 y = x[i].sigmoid()
 52 |                 y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i]) * self.stride[i]  # xy
 53 |                 y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  # wh
 54 |                 z.append(y.view(bs, -1, self.no))
 55 | 
 56 |         return x if self.training else (torch.cat(z, 1), x)
 57 | 
 58 |     @staticmethod
 59 |     def _make_grid(nx=20, ny=20):
 60 |         yv, xv = torch.meshgrid([torch.arange(ny), torch.arange(nx)])
 61 |         return torch.stack((xv, yv), 2).view((1, 1, ny, nx, 2)).float()
 62 | 
 63 | 
 64 | class Model(nn.Module):
 65 |     def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None, anchors=None):  # model, input channels, number of classes
 66 |         super(Model, self).__init__()
 67 |         if isinstance(cfg, dict):
 68 |             self.yaml = cfg  # model dict
 69 |         else:  # is *.yaml
 70 |             import yaml  # for torch hub
 71 |             self.yaml_file = Path(cfg).name
 72 |             with open(cfg) as f:
 73 |                 self.yaml = yaml.load(f, Loader=yaml.SafeLoader)  # model dict
 74 | 
 75 |         # Define model
 76 |         ch = self.yaml['ch'] = self.yaml.get('ch', ch)  # input channels
 77 |         if nc and nc != self.yaml['nc']:
 78 |             logger.info(f"Overriding model.yaml nc={self.yaml['nc']} with nc={nc}")
 79 |             self.yaml['nc'] = nc  # override yaml value
 80 |         if anchors:
 81 |             logger.info(f'Overriding model.yaml anchors with anchors={anchors}')
 82 |             self.yaml['anchors'] = round(anchors)  # override yaml value
 83 |         self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch])  # model, savelist
 84 |         self.names = [str(i) for i in range(self.yaml['nc'])]  # default names
 85 |         # print([x.shape for x in self.forward(torch.zeros(1, ch, 64, 64))])
 86 | 
 87 |         # Build strides, anchors
 88 |         m = self.model[-1]  # Detect()
 89 |         if isinstance(m, Detect):
 90 |             s = 256  # 2x min stride
 91 |             m.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))])  # forward
 92 |             m.anchors /= m.stride.view(-1, 1, 1)
 93 |             check_anchor_order(m)
 94 |             self.stride = m.stride
 95 |             self._initialize_biases()  # only run once
 96 |             # print('Strides: %s' % m.stride.tolist())
 97 | 
 98 |         # Init weights, biases
 99 |         initialize_weights(self)
100 |         self.info()
101 |         logger.info('')
102 | 
103 |     def forward(self, x, augment=False, profile=False):
104 |         if augment:
105 |             img_size = x.shape[-2:]  # height, width
106 |             s = [1, 0.83, 0.67]  # scales
107 |             f = [None, 3, None]  # flips (2-ud, 3-lr)
108 |             y = []  # outputs
109 |             for si, fi in zip(s, f):
110 |                 xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max()))
111 |                 yi = self.forward_once(xi)[0]  # forward
112 |                 # cv2.imwrite(f'img_{si}.jpg', 255 * xi[0].cpu().numpy().transpose((1, 2, 0))[:, :, ::-1])  # save
113 |                 yi[..., :4] /= si  # de-scale
114 |                 if fi == 2:
115 |                     yi[..., 1] = img_size[0] - yi[..., 1]  # de-flip ud
116 |                 elif fi == 3:
117 |                     yi[..., 0] = img_size[1] - yi[..., 0]  # de-flip lr
118 |                 y.append(yi)
119 |             return torch.cat(y, 1), None  # augmented inference, train
120 |         else:
121 |             return self.forward_once(x, profile)  # single-scale inference, train
122 | 
123 |     def forward_once(self, x, profile=False):
124 |         y, dt = [], []  # outputs
125 |         for m in self.model:
126 |             if m.f != -1:  # if not from previous layer
127 |                 x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f]  # from earlier layers
128 | 
129 |             if profile:
130 |                 o = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 if thop else 0  # FLOPS
131 |                 t = time_synchronized()
132 |                 for _ in range(10):
133 |                     _ = m(x)
134 |                 dt.append((time_synchronized() - t) * 100)
135 |                 print('%10.1f%10.0f%10.1fms %-40s' % (o, m.np, dt[-1], m.type))
136 | 
137 |             x = m(x)  # run
138 |             y.append(x if m.i in self.save else None)  # save output
139 | 
140 |         if profile:
141 |             print('%.1fms total' % sum(dt))
142 |         return x
143 | 
144 |     def _initialize_biases(self, cf=None):  # initialize biases into Detect(), cf is class frequency
145 |         # https://arxiv.org/abs/1708.02002 section 3.3
146 |         # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.
147 |         m = self.model[-1]  # Detect() module
148 |         for mi, s in zip(m.m, m.stride):  # from
149 |             b = mi.bias.view(m.na, -1)  # conv.bias(255) to (3,85)
150 |             b.data[:, 4] += math.log(8 / (640 / s) ** 2)  # obj (8 objects per 640 image)
151 |             b.data[:, 5:] += math.log(0.6 / (m.nc - 0.99)) if cf is None else torch.log(cf / cf.sum())  # cls
152 |             mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)
153 | 
154 |     def _print_biases(self):
155 |         m = self.model[-1]  # Detect() module
156 |         for mi in m.m:  # from
157 |             b = mi.bias.detach().view(m.na, -1).T  # conv.bias(255) to (3,85)
158 |             print(('%6g Conv2d.bias:' + '%10.3g' * 6) % (mi.weight.shape[1], *b[:5].mean(1).tolist(), b[5:].mean()))
159 | 
160 |     # def _print_weights(self):
161 |     #     for m in self.model.modules():
162 |     #         if type(m) is Bottleneck:
163 |     #             print('%10.3g' % (m.w.detach().sigmoid() * 2))  # shortcut weights
164 | 
165 |     def fuse(self):  # fuse model Conv2d() + BatchNorm2d() layers
166 |         print('Fusing layers... ')
167 |         for m in self.model.modules():
168 |             if type(m) is Conv and hasattr(m, 'bn'):
169 |                 m.conv = fuse_conv_and_bn(m.conv, m.bn)  # update conv
170 |                 delattr(m, 'bn')  # remove batchnorm
171 |                 m.forward = m.fuseforward  # update forward
172 |         self.info()
173 |         return self
174 | 
175 |     def nms(self, mode=True):  # add or remove NMS module
176 |         present = type(self.model[-1]) is NMS  # last layer is NMS
177 |         if mode and not present:
178 |             print('Adding NMS... ')
179 |             m = NMS()  # module
180 |             m.f = -1  # from
181 |             m.i = self.model[-1].i + 1  # index
182 |             self.model.add_module(name='%s' % m.i, module=m)  # add
183 |             self.eval()
184 |         elif not mode and present:
185 |             print('Removing NMS... ')
186 |             self.model = self.model[:-1]  # remove
187 |         return self
188 | 
189 |     def autoshape(self):  # add autoShape module
190 |         print('Adding autoShape... ')
191 |         m = autoShape(self)  # wrap model
192 |         copy_attr(m, self, include=('yaml', 'nc', 'hyp', 'names', 'stride'), exclude=())  # copy attributes
193 |         return m
194 | 
195 |     def info(self, verbose=False, img_size=640):  # print model information
196 |         model_info(self, verbose, img_size)
197 | 
198 | 
199 | def parse_model(d, ch):  # model_dict, input_channels(3)
200 |     logger.info('\n%3s%18s%3s%10s  %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))
201 |     anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
202 |     na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
203 |     no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)
204 | 
205 |     layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
206 |     for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
207 |         m = eval(m) if isinstance(m, str) else m  # eval strings
208 |         for j, a in enumerate(args):
209 |             try:
210 |                 args[j] = eval(a) if isinstance(a, str) else a  # eval strings
211 |             except:
212 |                 pass
213 | 
214 |         n = max(round(n * gd), 1) if n > 1 else n  # depth gain
215 |         if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,
216 |                  C3]:
217 |             c1, c2 = ch[f], args[0]
218 |             if c2 != no:  # if not output
219 |                 c2 = make_divisible(c2 * gw, 8)
220 | 
221 |             args = [c1, c2, *args[1:]]
222 |             if m in [BottleneckCSP, C3]:
223 |                 args.insert(2, n)  # number of repeats
224 |                 n = 1
225 |         elif m is nn.BatchNorm2d:
226 |             args = [ch[f]]
227 |         elif m is Concat:
228 |             c2 = sum([ch[x] for x in f])
229 |         elif m is Detect:
230 |             args.append([ch[x] for x in f])
231 |             if isinstance(args[1], int):  # number of anchors
232 |                 args[1] = [list(range(args[1] * 2))] * len(f)
233 |         elif m is Contract:
234 |             c2 = ch[f] * args[0] ** 2
235 |         elif m is Expand:
236 |             c2 = ch[f] // args[0] ** 2
237 |         else:
238 |             c2 = ch[f]
239 | 
240 |         m_ = nn.Sequential(*[m(*args) for _ in range(n)]) if n > 1 else m(*args)  # module
241 |         t = str(m)[8:-2].replace('__main__.', '')  # module type
242 |         np = sum([x.numel() for x in m_.parameters()])  # number params
243 |         m_.i, m_.f, m_.type, m_.np = i, f, t, np  # attach index, 'from' index, type, number params
244 |         logger.info('%3s%18s%3s%10.0f  %-40s%-30s' % (i, f, n, np, t, args))  # print
245 |         save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
246 |         layers.append(m_)
247 |         if i == 0:
248 |             ch = []
249 |         ch.append(c2)
250 |     return nn.Sequential(*layers), sorted(save)
251 | 
252 | 
253 | if __name__ == '__main__':
254 |     parser = argparse.ArgumentParser()
255 |     parser.add_argument('--cfg', type=str, default='yolov5s.yaml', help='model.yaml')
256 |     parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
257 |     opt = parser.parse_args()
258 |     opt.cfg = check_file(opt.cfg)  # check file
259 |     set_logging()
260 |     device = select_device(opt.device)
261 | 
262 |     # Create model
263 |     model = Model(opt.cfg).to(device)
264 |     model.train()
265 | 
266 |     # Profile
267 |     # img = torch.rand(8 if torch.cuda.is_available() else 1, 3, 640, 640).to(device)
268 |     # y = model(img, profile=True)
269 | 
270 |     # Tensorboard
271 |     # from torch.utils.tensorboard import SummaryWriter
272 |     # tb_writer = SummaryWriter()
273 |     # print("Run 'tensorboard --logdir=models/runs' to view tensorboard at http://localhost:6006/")
274 |     # tb_writer.add_graph(model.model, img)  # add model to tensorboard
275 |     # tb_writer.add_image('test', img[0], dataformats='CWH')  # add model to tensorboard
276 | 


--------------------------------------------------------------------------------
/models/common.py:
--------------------------------------------------------------------------------
  1 | # This file contains modules common to various models
  2 | 
  3 | import math
  4 | from pathlib import Path
  5 | 
  6 | import numpy as np
  7 | import requests
  8 | import torch
  9 | import torch.nn as nn
 10 | from PIL import Image
 11 | 
 12 | from utils.datasets import letterbox
 13 | from utils.general import non_max_suppression, make_divisible, scale_coords, xyxy2xywh
 14 | from utils.plots import color_list, plot_one_box
 15 | 
 16 | 
 17 | def autopad(k, p=None):  # kernel, padding
 18 |     # Pad to 'same'
 19 |     if p is None:
 20 |         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
 21 |     return p
 22 | 
 23 | 
 24 | def DWConv(c1, c2, k=1, s=1, act=True):
 25 |     # Depthwise convolution
 26 |     return Conv(c1, c2, k, s, g=math.gcd(c1, c2), act=act)
 27 | 
 28 | 
 29 | class Conv(nn.Module):
 30 |     # Standard convolution
 31 |     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
 32 |         super(Conv, self).__init__()
 33 |         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
 34 |         self.bn = nn.BatchNorm2d(c2)
 35 |         self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
 36 | 
 37 |     def forward(self, x):
 38 |         return self.act(self.bn(self.conv(x)))
 39 | 
 40 |     def fuseforward(self, x):
 41 |         return self.act(self.conv(x))
 42 | 
 43 | 
 44 | class Bottleneck(nn.Module):
 45 |     # Standard bottleneck
 46 |     def __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, expansion
 47 |         super(Bottleneck, self).__init__()
 48 |         c_ = int(c2 * e)  # hidden channels
 49 |         self.cv1 = Conv(c1, c_, 1, 1)
 50 |         self.cv2 = Conv(c_, c2, 3, 1, g=g)
 51 |         self.add = shortcut and c1 == c2
 52 | 
 53 |     def forward(self, x):
 54 |         return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
 55 | 
 56 | 
 57 | class BottleneckCSP(nn.Module):
 58 |     # CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
 59 |     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
 60 |         super(BottleneckCSP, self).__init__()
 61 |         c_ = int(c2 * e)  # hidden channels
 62 |         self.cv1 = Conv(c1, c_, 1, 1)
 63 |         self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False)
 64 |         self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False)
 65 |         self.cv4 = Conv(2 * c_, c2, 1, 1)
 66 |         self.bn = nn.BatchNorm2d(2 * c_)  # applied to cat(cv2, cv3)
 67 |         self.act = nn.LeakyReLU(0.1, inplace=True)
 68 |         self.m = nn.Sequential(*[Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)])
 69 | 
 70 |     def forward(self, x):
 71 |         y1 = self.cv3(self.m(self.cv1(x)))
 72 |         y2 = self.cv2(x)
 73 |         return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))
 74 | 
 75 | 
 76 | class C3(nn.Module):
 77 |     # CSP Bottleneck with 3 convolutions
 78 |     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
 79 |         super(C3, self).__init__()
 80 |         c_ = int(c2 * e)  # hidden channels
 81 |         self.cv1 = Conv(c1, c_, 1, 1)
 82 |         self.cv2 = Conv(c1, c_, 1, 1)
 83 |         self.cv3 = Conv(2 * c_, c2, 1)  # act=FReLU(c2)
 84 |         self.m = nn.Sequential(*[Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)])
 85 |         # self.m = nn.Sequential(*[CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)])
 86 | 
 87 |     def forward(self, x):
 88 |         return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1))
 89 | 
 90 | 
 91 | class SPP(nn.Module):
 92 |     # Spatial pyramid pooling layer used in YOLOv3-SPP
 93 |     def __init__(self, c1, c2, k=(5, 9, 13)):
 94 |         super(SPP, self).__init__()
 95 |         c_ = c1 // 2  # hidden channels
 96 |         self.cv1 = Conv(c1, c_, 1, 1)
 97 |         self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
 98 |         self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
 99 | 
100 |     def forward(self, x):
101 |         x = self.cv1(x)
102 |         return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))
103 | 
104 | 
105 | class Focus(nn.Module):
106 |     # Focus wh information into c-space
107 |     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
108 |         super(Focus, self).__init__()
109 |         self.conv = Conv(c1 * 4, c2, k, s, p, g, act)
110 |         # self.contract = Contract(gain=2)
111 | 
112 |     def forward(self, x):  # x(b,c,w,h) -> y(b,4c,w/2,h/2)
113 |         return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], 1))
114 |         # return self.conv(self.contract(x))
115 | 
116 | 
117 | class Contract(nn.Module):
118 |     # Contract width-height into channels, i.e. x(1,64,80,80) to x(1,256,40,40)
119 |     def __init__(self, gain=2):
120 |         super().__init__()
121 |         self.gain = gain
122 | 
123 |     def forward(self, x):
124 |         N, C, H, W = x.size()  # assert (H / s == 0) and (W / s == 0), 'Indivisible gain'
125 |         s = self.gain
126 |         x = x.view(N, C, H // s, s, W // s, s)  # x(1,64,40,2,40,2)
127 |         x = x.permute(0, 3, 5, 1, 2, 4).contiguous()  # x(1,2,2,64,40,40)
128 |         return x.view(N, C * s * s, H // s, W // s)  # x(1,256,40,40)
129 | 
130 | 
131 | class Expand(nn.Module):
132 |     # Expand channels into width-height, i.e. x(1,64,80,80) to x(1,16,160,160)
133 |     def __init__(self, gain=2):
134 |         super().__init__()
135 |         self.gain = gain
136 | 
137 |     def forward(self, x):
138 |         N, C, H, W = x.size()  # assert C / s ** 2 == 0, 'Indivisible gain'
139 |         s = self.gain
140 |         x = x.view(N, s, s, C // s ** 2, H, W)  # x(1,2,2,16,80,80)
141 |         x = x.permute(0, 3, 4, 1, 5, 2).contiguous()  # x(1,16,80,2,80,2)
142 |         return x.view(N, C // s ** 2, H * s, W * s)  # x(1,16,160,160)
143 | 
144 | 
145 | class Concat(nn.Module):
146 |     # Concatenate a list of tensors along dimension
147 |     def __init__(self, dimension=1):
148 |         super(Concat, self).__init__()
149 |         self.d = dimension
150 | 
151 |     def forward(self, x):
152 |         return torch.cat(x, self.d)
153 | 
154 | 
155 | class NMS(nn.Module):
156 |     # Non-Maximum Suppression (NMS) module
157 |     conf = 0.25  # confidence threshold
158 |     iou = 0.45  # IoU threshold
159 |     classes = None  # (optional list) filter by class
160 | 
161 |     def __init__(self):
162 |         super(NMS, self).__init__()
163 | 
164 |     def forward(self, x):
165 |         return non_max_suppression(x[0], conf_thres=self.conf, iou_thres=self.iou, classes=self.classes)
166 | 
167 | 
168 | class autoShape(nn.Module):
169 |     # input-robust model wrapper for passing cv2/np/PIL/torch inputs. Includes preprocessing, inference and NMS
170 |     img_size = 640  # inference size (pixels)
171 |     conf = 0.25  # NMS confidence threshold
172 |     iou = 0.45  # NMS IoU threshold
173 |     classes = None  # (optional list) filter by class
174 | 
175 |     def __init__(self, model):
176 |         super(autoShape, self).__init__()
177 |         self.model = model.eval()
178 | 
179 |     def autoshape(self):
180 |         print('autoShape already enabled, skipping... ')  # model already converted to model.autoshape()
181 |         return self
182 | 
183 |     def forward(self, imgs, size=640, augment=False, profile=False):
184 |         # Inference from various sources. For height=720, width=1280, RGB images example inputs are:
185 |         #   filename:   imgs = 'data/samples/zidane.jpg'
186 |         #   URI:             = 'https://github.com/ultralytics/yolov5/releases/download/v1.0/zidane.jpg'
187 |         #   OpenCV:          = cv2.imread('image.jpg')[:,:,::-1]  # HWC BGR to RGB x(720,1280,3)
188 |         #   PIL:             = Image.open('image.jpg')  # HWC x(720,1280,3)
189 |         #   numpy:           = np.zeros((720,1280,3))  # HWC
190 |         #   torch:           = torch.zeros(16,3,720,1280)  # BCHW
191 |         #   multiple:        = [Image.open('image1.jpg'), Image.open('image2.jpg'), ...]  # list of images
192 | 
193 |         p = next(self.model.parameters())  # for device and type
194 |         if isinstance(imgs, torch.Tensor):  # torch
195 |             return self.model(imgs.to(p.device).type_as(p), augment, profile)  # inference
196 | 
197 |         # Pre-process
198 |         n, imgs = (len(imgs), imgs) if isinstance(imgs, list) else (1, [imgs])  # number of images, list of images
199 |         shape0, shape1, files = [], [], []  # image and inference shapes, filenames
200 |         for i, im in enumerate(imgs):
201 |             if isinstance(im, str):  # filename or uri
202 |                 im, f = Image.open(requests.get(im, stream=True).raw if im.startswith('http') else im), im  # open
203 |                 im.filename = f  # for uri
204 |             files.append(Path(im.filename).with_suffix('.jpg').name if isinstance(im, Image.Image) else f'image{i}.jpg')
205 |             im = np.array(im)  # to numpy
206 |             if im.shape[0] < 5:  # image in CHW
207 |                 im = im.transpose((1, 2, 0))  # reverse dataloader .transpose(2, 0, 1)
208 |             im = im[:, :, :3] if im.ndim == 3 else np.tile(im[:, :, None], 3)  # enforce 3ch input
209 |             s = im.shape[:2]  # HWC
210 |             shape0.append(s)  # image shape
211 |             g = (size / max(s))  # gain
212 |             shape1.append([y * g for y in s])
213 |             imgs[i] = im  # update
214 |         shape1 = [make_divisible(x, int(self.stride.max())) for x in np.stack(shape1, 0).max(0)]  # inference shape
215 |         x = [letterbox(im, new_shape=shape1, auto=False)[0] for im in imgs]  # pad
216 |         x = np.stack(x, 0) if n > 1 else x[0][None]  # stack
217 |         x = np.ascontiguousarray(x.transpose((0, 3, 1, 2)))  # BHWC to BCHW
218 |         x = torch.from_numpy(x).to(p.device).type_as(p) / 255.  # uint8 to fp16/32
219 | 
220 |         # Inference
221 |         with torch.no_grad():
222 |             y = self.model(x, augment, profile)[0]  # forward
223 |         y = non_max_suppression(y, conf_thres=self.conf, iou_thres=self.iou, classes=self.classes)  # NMS
224 | 
225 |         # Post-process
226 |         for i in range(n):
227 |             scale_coords(shape1, y[i][:, :4], shape0[i])
228 | 
229 |         return Detections(imgs, y, files, self.names)
230 | 
231 | 
232 | class Detections:
233 |     # detections class for YOLOv5 inference results
234 |     def __init__(self, imgs, pred, files, names=None):
235 |         super(Detections, self).__init__()
236 |         d = pred[0].device  # device
237 |         gn = [torch.tensor([*[im.shape[i] for i in [1, 0, 1, 0]], 1., 1.], device=d) for im in imgs]  # normalizations
238 |         self.imgs = imgs  # list of images as numpy arrays
239 |         self.pred = pred  # list of tensors pred[0] = (xyxy, conf, cls)
240 |         self.names = names  # class names
241 |         self.files = files  # image filenames
242 |         self.xyxy = pred  # xyxy pixels
243 |         self.xywh = [xyxy2xywh(x) for x in pred]  # xywh pixels
244 |         self.xyxyn = [x / g for x, g in zip(self.xyxy, gn)]  # xyxy normalized
245 |         self.xywhn = [x / g for x, g in zip(self.xywh, gn)]  # xywh normalized
246 |         self.n = len(self.pred)
247 | 
248 |     def display(self, pprint=False, show=False, save=False, render=False, save_dir=''):
249 |         colors = color_list()
250 |         for i, (img, pred) in enumerate(zip(self.imgs, self.pred)):
251 |             str = f'image {i + 1}/{len(self.pred)}: {img.shape[0]}x{img.shape[1]} '
252 |             if pred is not None:
253 |                 for c in pred[:, -1].unique():
254 |                     n = (pred[:, -1] == c).sum()  # detections per class
255 |                     str += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, "  # add to string
256 |                 if show or save or render:
257 |                     for *box, conf, cls in pred:  # xyxy, confidence, class
258 |                         label = f'{self.names[int(cls)]} {conf:.2f}'
259 |                         plot_one_box(box, img, label=label, color=colors[int(cls) % 10])
260 |             img = Image.fromarray(img.astype(np.uint8)) if isinstance(img, np.ndarray) else img  # from np
261 |             if pprint:
262 |                 print(str.rstrip(', '))
263 |             if show:
264 |                 img.show(self.files[i])  # show
265 |             if save:
266 |                 f = Path(save_dir) / self.files[i]
267 |                 img.save(f)  # save
268 |                 print(f"{'Saving' * (i == 0)} {f},", end='' if i < self.n - 1 else ' done.\n')
269 |             if render:
270 |                 self.imgs[i] = np.asarray(img)
271 | 
272 |     def print(self):
273 |         self.display(pprint=True)  # print results
274 | 
275 |     def show(self):
276 |         self.display(show=True)  # show results
277 | 
278 |     def save(self, save_dir='results/'):
279 |         Path(save_dir).mkdir(exist_ok=True)
280 |         self.display(save=True, save_dir=save_dir)  # save results
281 | 
282 |     def render(self):
283 |         self.display(render=True)  # render results
284 |         return self.imgs
285 | 
286 |     def __len__(self):
287 |         return self.n
288 | 
289 |     def tolist(self):
290 |         # return a list of Detections objects, i.e. 'for result in results.tolist():'
291 |         x = [Detections([self.imgs[i]], [self.pred[i]], self.names) for i in range(self.n)]
292 |         for d in x:
293 |             for k in ['imgs', 'pred', 'xyxy', 'xyxyn', 'xywh', 'xywhn']:
294 |                 setattr(d, k, getattr(d, k)[0])  # pop out of list
295 |         return x
296 | 
297 | 
298 | class Classify(nn.Module):
299 |     # Classification head, i.e. x(b,c1,20,20) to x(b,c2)
300 |     def __init__(self, c1, c2, k=1, s=1, p=None, g=1):  # ch_in, ch_out, kernel, stride, padding, groups
301 |         super(Classify, self).__init__()
302 |         self.aap = nn.AdaptiveAvgPool2d(1)  # to x(b,c1,1,1)
303 |         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g)  # to x(b,c2,1,1)
304 |         self.flat = nn.Flatten()
305 | 
306 |     def forward(self, x):
307 |         z = torch.cat([self.aap(y) for y in (x if isinstance(x, list) else [x])], 1)  # cat if list
308 |         return self.flat(self.conv(z))  # flatten to x(b,c2)
309 | 


--------------------------------------------------------------------------------