![\"[LOGO]:CoreKSets](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235529-680ec3f1364f5.png\")
<\/p>\n<\/p>\n
\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u3010\u6838\u77e5\u574a\u3011：\u91ca\u653e\u9752\u6625\u60f3\u8c61，\u7801\u52a8\u5168\u65b0\u89c6\u91ce\u3002\u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u6211\u4eec\u5e0c\u671b\u4f7f\u7528\u7cbe\u7b80\u7684\u4fe1\u606f\u4f20\u8fbe\u77e5\u8bc6\u7684\u9aa8\u67b6，\u542f\u53d1\u521b\u9020\u8005\u5f00\u542f\u521b\u9020\u4e4b\u8def！！！\u00a0 \u00a0 \u00a0 \u00a0 \u00a0\u00a0<\/span><\/span><\/p>\n \u5185\u5bb9\u6458\u8981<\/span>：<\/span>\u6700\u8fd1\u9700\u8981\u4f7f\u7528 YOLOv5 \u6846\u67b6\u8bad\u7ec3\u4e00\u4e2a\u8bc6\u522b\u6a21\u578b，\u6570\u636e\u96c6\u67095000\u591a\u5f20\u56fe\u7247，\u76f4\u63a5\u57283000\u7b14\u8bb0\u672cCPU\u4e0a\u8dd1，\u6015\u662f\u8981\u51e0\u5929\u3002\u4e8e\u662f\u4ed8\u8d39\u4f7f\u7528 OpenBayes \u7684\u4e91\u670d\u52a1\u5668，\u4f46\u4e91\u670d\u52a1\u5668\u4f7f\u7528\u4ef7\u683c\u8f83\u8d35，\u914d\u7f6e\u91cd\u590d\u3002\u5bf9\u5c0f\u4f17\u9700\u6c42\u8005\u4e0d\u592a\u53cb\u597d，\u4e8e\u662f\u6211\u53bb Kaggle \u5c1d\u8bd5\u4e86\u767d\u5ad6\u670d\u52a1\u5668，\u5e76\u6210\u529f\u8bad\u7ec3\u4e86\u81ea\u5df1\u7684\u6a21\u578b\u3002<\/p>\n \u5173\u952e\u8bcd<\/span>：YOLOv5 Kaggle \u6a21\u578b\u8bad\u7ec3 <\/p>\n \u5176\u4ed6\u76f8\u5173\u6587\u7ae0：<\/p>\n \u26cf\u3002\u3002\u3002<\/p>\n<\/p>\n \u82b1\u94b1\u53bbOpenBayes\u5f00\u4e91\u8ba1\u7b97\u670d\u52a1\u5668\u8fdb\u884c\u6a21\u578b\u8bad\u7ec3，\u82b1\u94b1\u8bad\u7ec3\u7684\u5c31\u662f\u5feb，\u5927\u5185\u5b58\u53ef\u4ee5\u76f4\u63a5\u914d\u7f6e batch-size \u6279\u6b21 32 \u6216\u8005 64\u3002\u5934\u75bc\u7684\u7684\u6bcf\u6b21\u542f\u52a8\u90fd\u8981\u914d\u7f6e\u4e00\u4e0b\u73af\u5883，\u4e0b\u8f7d\u4e00\u4e9b\u4f9d\u8d56\u5305（\u5173\u95ed\u4f1a\u88ab\u6e05\u9664，\u4e0d\u6e05\u695a\u539f\u56e0），\u6b63\u5f0f\u5f00\u59cb\u4f7f\u7528\u4e4b\u524d\u90fd\u8981\u82b1\u8d3910\u5206\u949f\u65f6\u95f4\u3002\u7528\u4e86\u51e0\u5929，\u82b1\u4e86\u621150\u5757\u5927\u6d0b\u540e，\u5fc3\u75bc\u4e0d\u5df2，\u4e8e\u662f\u53bbKaggle\u770b\u770b\u80fd\u4e0d\u80fd\u514d\u8d39\u8bad\u7ec3\u3002<\/p>\n OpenBayes\u5bf9\u65b0\u7528\u6237\u4f18\u60e0\u529b\u5ea6\u5f88\u5927，\u6ce8\u518c\u8d60\u9001 240 \u5206\u949f RTX 4090 \u4f7f\u7528\u65f6\u957f+ 300 \u5206\u949f\u9ad8\u6027\u80fd CPU \u4f7f\u7528\u65f6\u957f\u3002\u76f4\u63a5\u70b9\u51fb\u524d\u5f80：signup – OpenBayes<\/p>\n<\/p>\n Kaggle \u662f\u4e00\u4e2a\u5168\u7403\u9886\u5148\u7684\u6570\u636e\u79d1\u5b66\u548c\u673a\u5668\u5b66\u4e60\u5e73\u53f0，\u7531 Anthony Goldbloom \u548c Ben Hamner \u4e8e 2010 \u5e74\u521b\u7acb，\u5e76\u4e8e 2017 \u5e74\u88ab Google \u6536\u8d2d，\u73b0\u4e3a Google LLC \u7684\u5b50\u516c\u53f8\u3002Kaggle \u63d0\u4f9b\u4e86\u4e00\u4e2a\u5728\u7ebf\u793e\u533a，\u6c47\u805a\u4e86\u6765\u81ea\u4e16\u754c\u5404\u5730\u7684\u6570\u636e\u79d1\u5b66\u5bb6\u548c\u673a\u5668\u5b66\u4e60\u5de5\u7a0b\u5e08，\u81f4\u529b\u4e8e\u901a\u8fc7\u7ade\u8d5b\u3001\u6570\u636e\u96c6\u5206\u4eab\u548c\u4ee3\u7801\u534f\u4f5c\u63a8\u52a8\u4eba\u5de5\u667a\u80fd\u7684\u53d1\u5c55\u3002<\/p>\n 🎁 Kaggle \u6bcf\u5468\u798f\u5229：\u514d\u8d39 GPU \u4f7f\u7528<\/p>\n \u2705 \u6bcf\u5468 30 \u5c0f\u65f6\u514d\u8d39 GPU \u8d44\u6e90<\/p>\n Kaggle \u4e3a\u6bcf\u4f4d\u7528\u6237\u6bcf\u5468\u63d0\u4f9b 30 \u5c0f\u65f6 \u7684\u514d\u8d39 GPU \u4f7f\u7528\u65f6\u95f4\u3002\u8fd9\u4e9b GPU \u8d44\u6e90\u53ef\u7528\u4e8e\u5728 Kaggle \u7684 Jupyter Notebook \u73af\u5883\u4e2d\u8fd0\u884c\u548c\u8bad\u7ec3\u6a21\u578b\u3002<\/p>\n 💻 \u652f\u6301\u7684 GPU \u7c7b\u578b<\/p>\n Kaggle \u63d0\u4f9b\u7684 GPU \u7c7b\u578b\u5305\u62ec：<\/p>\n NVIDIA Tesla P100：16GB \u663e\u5b58，\u9002\u5408\u5927\u591a\u6570\u6df1\u5ea6\u5b66\u4e60\u4efb\u52a1\u3002<\/p>\n<\/li>\n NVIDIA T4：15GB \u663e\u5b58，\u652f\u6301\u6df7\u5408\u7cbe\u5ea6\u8ba1\u7b97，\u9002\u7528\u4e8e\u63a8\u7406\u548c\u8bad\u7ec3\u4efb\u52a1\u3002<\/p>\n<\/li>\n<\/ul>\n \u7528\u6237\u53ef\u4ee5\u5728 Notebook \u8bbe\u7f6e\u4e2d\u9009\u62e9\u6240\u9700\u7684 GPU \u7c7b\u578b\u3002<\/p>\n \u23f1\ufe0f \u4f7f\u7528\u9650\u5236<\/p>\n \u5355\u6b21\u8fd0\u884c\u65f6\u95f4：\u6bcf\u6b21 Notebook \u4f1a\u8bdd\u6700\u957f\u53ef\u8fd0\u884c 12 \u5c0f\u65f6，\u8d85\u8fc7\u65f6\u95f4\u5c06\u88ab\u5f3a\u5236\u4e2d\u65ad\u3002<\/p>\n<\/li>\n \u6bcf\u5468\u603b\u65f6\u957f：\u6bcf\u4f4d\u7528\u6237\u6bcf\u5468\u6700\u591a\u53ef\u4f7f\u7528 30 \u5c0f\u65f6 \u7684 GPU \u8d44\u6e90\u3002<\/p>\n<\/li>\n<\/ul>\n 🌟 Kaggle \u7684\u6838\u5fc3\u529f\u80fd<\/p>\n 1. \u7ade\u8d5b（Competitions）<\/p>\n Kaggle \u7684\u7ade\u8d5b\u5e73\u53f0\u5141\u8bb8\u4f01\u4e1a\u548c\u7814\u7a76\u673a\u6784\u53d1\u5e03\u5b9e\u9645\u95ee\u9898\u548c\u6570\u636e\u96c6，\u5438\u5f15\u5168\u7403\u7684\u6570\u636e\u79d1\u5b66\u5bb6\u53c2\u4e0e\u89e3\u51b3\u3002\u53c2\u8d5b\u8005\u9700\u5728\u89c4\u5b9a\u65f6\u95f4\u5185\u63d0\u4ea4\u6a21\u578b，\u5e73\u53f0\u6839\u636e\u9884\u8bbe\u7684\u8bc4\u4f30\u6307\u6807（\u5982\u51c6\u786e\u7387\u3001AUC \u7b49）\u8fdb\u884c\u6392\u540d\u3002\u4f18\u80dc\u8005\u4e0d\u4ec5\u53ef\u83b7\u5f97\u5956\u91d1，\u8fd8\u53ef\u80fd\u83b7\u5f97\u4e0e\u8d5e\u52a9\u4f01\u4e1a\u5408\u4f5c\u7684\u673a\u4f1a，\u751a\u81f3\u76f4\u63a5\u53d7\u8058\u4e8e\u8fd9\u4e9b\u516c\u53f8\u3002PyTorch Tutorial<\/p>\n 2.\u6570\u636e\u96c6（Datasets）<\/p>\n Kaggle \u63d0\u4f9b\u4e86\u4e30\u5bcc\u7684\u5f00\u653e\u6570\u636e\u96c6，\u6db5\u76d6\u81ea\u7136\u8bed\u8a00\u5904\u7406\u3001\u8ba1\u7b97\u673a\u89c6\u89c9\u3001\u91d1\u878d\u5206\u6790\u7b49\u591a\u4e2a\u9886\u57df\u3002\u7528\u6237\u53ef\u4ee5\u6d4f\u89c8\u3001\u4e0b\u8f7d\u8fd9\u4e9b\u6570\u636e\u96c6，\u7528\u4e8e\u5b66\u4e60\u3001\u7814\u7a76\u6216\u9879\u76ee\u5f00\u53d1\u3002kaggle-china.com<\/p>\n 3.\u4ee3\u7801\u5171\u4eab（Code \/ Notebooks）<\/p>\n Kaggle \u63d0\u4f9b\u57fa\u4e8e\u4e91\u7684 Jupyter Notebook \u73af\u5883，\u79f0\u4e3a Kernels，\u7528\u6237\u53ef\u4ee5\u5728\u5176\u4e2d\u7f16\u5199\u3001\u8fd0\u884c\u548c\u5206\u4eab\u4ee3\u7801，\u8fdb\u884c\u6570\u636e\u5206\u6790\u548c\u6a21\u578b\u8bad\u7ec3\u3002\u8fd9\u4fc3\u8fdb\u4e86\u793e\u533a\u6210\u5458\u4e4b\u95f4\u7684\u534f\u4f5c\u4e0e\u5b66\u4e60\u3002kaggle-china.com<\/p>\n 4.\u5b66\u4e60\u8d44\u6e90（Kaggle Learn）<\/p>\n Kaggle Learn \u63d0\u4f9b\u4e86\u4e00\u7cfb\u5217\u514d\u8d39\u7684\u5fae\u8bfe\u7a0b，\u6db5\u76d6 Python \u7f16\u7a0b\u3001\u6570\u636e\u53ef\u89c6\u5316\u3001\u673a\u5668\u5b66\u4e60\u3001\u6df1\u5ea6\u5b66\u4e60\u7b49\u4e3b\u9898，\u5e2e\u52a9\u7528\u6237\u7cfb\u7edf\u5730\u63d0\u5347\u6280\u80fd\u3002<\/p>\n<\/p>\n \u6570\u636e\u96c6\u51c6\u5907：<\/p>\n \u6309\u7167YOLO\u8981\u6c42\u7684\u683c\u5f0f，\u628a\u6570\u636e\u96c6\u6574\u7406\u597d\u540e\u6253\u5305\u4e3a data.zip \u538b\u7f29\u5305： \u767b\u5f55\u6216\u6ce8\u518cKaggle\u540e\u70b9\u51fb\u5de6\u4fa7\u5bfc\u822a\u680f You Work :<\/p>\n \u70b9\u51fb Create,\u9009\u62e9 New Dataset:<\/p>\n \u70b9\u51fb New Dataset:<\/p>\n \u53f3\u4fa7\u4f1a\u51fa\u73b0\u4e0a\u4f20\u754c\u9762，\u70b9\u51fb\u4e0a\u4f20 data.zip \u538b\u7f29\u5305，\u8be5\u8fc7\u7a0b\u770b\u4f60\u7684\u6570\u636e\u5927\u5c0f，\u9700\u8981\u8010\u5fc3\u7b49\u5f85\u3002\u8f93\u5165\u6570\u636e\u96c6\u540d\u79f0，\u53ef\u4ee5\u8ffd\u52a0\u4e0a\u4f20\u66f4\u591a\u6587\u4ef6\u3002\u6700\u540e\u70b9\u51fb\u53f3\u4e0b\u89d2 Create \u5b8c\u6210\u6570\u636e\u96c6\u521b\u5efa\u3002<\/p>\n \u521b\u5efa\u6210\u529f\u540e\u4f60\u53ef\u4ee5\u5728\u5de6\u4fa7\u5bfc\u822a\u680f\u7684 You Work \u5185\u7684 DataSets \u770b\u5230\u6240\u6709\u4f60\u7684\u6570\u636e\u96c6\u3002<\/p>\n \u70b9\u51fb Create,\u9009\u62e9 New Notebook:<\/p>\n \u8fdb\u5165\u754c\u9762\u540e，\u70b9\u51fb\u53f3\u4fa7 +Add Input \u6309\u94ae\u9884\u89c8\u6570\u636e\u96c6，\u5982\u679c\u4f60\u9884\u89c8\u8fc7\u81ea\u5df1\u521a\u4e0a\u4f20\u7684\u6570\u636e\u5e93，\u5c31\u53ef\u4ee5\u76f4\u63a5\u770b\u5230\u5b83，\u6ca1\u6709\u8bf7\u53bb\u9884\u89c8\u4e00\u4e0b\u3002<\/p>\n \u7136\u540e\u70b9\u51fb\u4f60\u7684\u6570\u636e\u5e93\u9009\u9879\u53f3\u4e0b\u89d2\u7684 \u2795 \u53f7：<\/p>\n \u73b0\u5728\u5f00\u59cb，\u76f4\u63a5\u4f7f\u7528\u7f16\u8f91\u5668\u5f00\u59cb\u8fd0\u884c\u4ee3\u7801，\u670d\u52a1\u5668\u578b\u53f7\u53ef\u4ee5\u5728 Settings->Accelerator \u9009\u62e9：<\/p>\n \u7b2c\u4e00\u6b21\u8fd0\u884c\u4ee3\u7801\u65f6\u7cfb\u7edf\u81ea\u52a8\u542f\u52a8\u670d\u52a1\u5668<\/p>\n \u8bed\u6cd5\u89c4\u5219（\u82f1\u6587）：<\/p>\n shell \u547d\u4ee4： \u4f7f\u7528\u611f\u53f9\u53f7\u201c!\u201d \u4f5c\u4e3a\u524d\u7f00，\u76f4\u63a5\u53ef\u4ee5\u5728\u7f16\u8f91\u5668\u4e2d\u8fd0\u884c\u3002<\/p>\n<\/li>\n python \u4ee3\u7801：\u76f4\u63a5\u5199<\/p>\n<\/li>\n<\/ul>\n \u62c9\u53d6YOLOv5\u6846\u67b6\u6e90\u7801，\u7b49\u5f85\u4e0b\u8f7d\u5b8c\u6210：<\/p>\n \u00a0!git clone https:\/\/github.com\/ultralytics\/yolov5 <\/p>\n \u5b8c\u6210\u540e，\u4f60\u53ef\u4ee5\u5728\u53f3\u4fa7\u72b6\u6001\u680f\u770b\u5230\u6587\u4ef6\u5939\u76ee\u5f55：<\/p>\n \u5207\u6362\u76ee\u5f55，\u8fdb\u5165yolov5\u6846\u67b6，\u5b89\u88c5\u4f9d\u8d56：<\/p>\n # \u5207\u6362\u5de5\u4f5c\u76ee\u5f55 \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u73b0\u5728，\u53ef\u4ee5\u4e3a\u6240\u6b32\u4e3a\u4e86！！！\u4f46\u662fKaggel\u7684\u7f16\u8f91\u5668\u4e0d\u80fd\u5728\u7ebf\u7f16\u8f91\u6846\u67b6\u91cc\u7684\u6e90\u7801，\u6240\u4ee5\u6211\u4eec\u76f4\u63a5\u4f7f\u7528\u6574\u4e2a\u6587\u4ef6\u5185\u5bb9\u66ff\u6362\u547d\u4ee4：\u7b2c\u4e00\u884c (%%writefile + \u6587\u4ef6\u8def\u5f84 ), \u7b2c\u4e00\u884c\u4e0b\u7684\u6240\u6709\u5185\u5bb9\u4f1a\u8986\u76d6\u539f\u59cb\u6587\u4ef6\u5185\u5bb9\u3002\u6211\u5efa\u8bae，\u81ea\u5df1\u5728\u7b14\u8bb0\u672c\u4e0a\u4fee\u6539，\u6539\u597d\u540e\u76f4\u63a5\u590d\u5236\u7c98\u8d34\u3002\u6ce8\u610f\u8def\u5f84\u524d\u7f00<\/span> \/kaggle\/working\/<\/p>\n %%writefile \/kaggle\/working\/yolov5\/data\/coco128.yaml<\/span><\/p>\n path: \/kaggle\/input\/handsdata<\/span><\/p>\n %%writefile \/kaggle\/working\/yolov5\/data\/coco128.yaml %%writefile \/kaggle\/working\/yolov5\/data\/hyps\/hyp.scratch-low.yaml %%writefile \/kaggle\/working\/yolov5\/models\/yolov5n.yaml # YOLOv5 v6.0 head [-1, 1, Conv, [256, 1, 1]], [-1, 1, Conv, [256, 3, 2]], [-1, 1, Conv, [512, 3, 2]], [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5) %%writefile \/kaggle\/working\/yolov5\/models\/common.py # Ultralytics 🚀 AGPL-3.0 License – https:\/\/ultralytics.com\/license import ast import cv2 # Import 'ultralytics' package or install if missing assert hasattr(ultralytics, "__version__") # verify package is not directory os.system("pip install -U ultralytics") from ultralytics.utils.plotting import Annotator, colors, save_one_box<\/p>\n from utils import TryExcept def autopad(k, p=None, d=1): `k`: kernel, `p`: padding, `d`: dilation. class Conv(nn.Module): default_act = nn.ReLU6() # default activation<\/p>\n def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True): def forward(self, x): def forward_fuse(self, x): class DWConv(Conv): def __init__(self, c1, c2, k=1, s=1, d=1, act=True): class DWConvTranspose2d(nn.ConvTranspose2d): def __init__(self, c1, c2, k=1, s=1, p1=0, p2=0): class TransformerLayer(nn.Module): def __init__(self, c, num_heads): See as described in https:\/\/arxiv.org\/abs\/2010.11929. def forward(self, x): class TransformerBlock(nn.Module): def __init__(self, c1, c2, num_heads, num_layers): def forward(self, x): class Bottleneck(nn.Module): def __init__(self, c1, c2, shortcut=True, g=1, e=0.5): def forward(self, x): class BottleneckCSP(nn.Module): def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): def forward(self, x): class CrossConv(nn.Module): def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False): Inputs are ch_in, ch_out, kernel, stride, groups, expansion, shortcut. def forward(self, x): class C3(nn.Module): def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): def forward(self, x): class C3x(C3): def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): class C3TR(C3): def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): class C3SPP(C3): def __init__(self, c1, c2, k=(5, 9, 13), n=1, shortcut=True, g=1, e=0.5): class C3Ghost(C3): def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): class SPP(nn.Module): def __init__(self, c1, c2, k=(5, 9, 13)): def forward(self, x): class SPPF(nn.Module): def __init__(self, c1, c2, k=5): Equivalent to SPP(k=(5, 9, 13)). def forward(self, x): class Focus(nn.Module): def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True): def forward(self, x): class GhostConv(nn.Module): def __init__(self, c1, c2, k=1, s=1, g=1, act=True): def forward(self, x): class GhostBottleneck(nn.Module): def __init__(self, c1, c2, k=3, s=1): def forward(self, x): class Contract(nn.Module): def __init__(self, gain=2): def forward(self, x): class Expand(nn.Module): def __init__(self, gain=2): Example: x(1,64,80,80) to x(1,16,160,160). def forward(self, x): class Concat(nn.Module): def __init__(self, dimension=1): def forward(self, x): class DetectMultiBackend(nn.Module): def __init__(self, weights="yolov5s.pt", device=torch.device("cpu"), dnn=False, data=None, fp16=False, fuse=True): super().__init__() if pt: # PyTorch providers = ["CUDAExecutionProvider", "CPUExecutionProvider"] if cuda else ["CPUExecutionProvider"] core = Core() check_version(trt.__version__, "7.0.0", hard=True) # require tensorrt>=7.0.0 model = ct.models.MLModel(w) keras = False # assume TF1 saved_model def wrap_frozen_graph(gd, inputs, outputs): def gd_outputs(gd): gd = tf.Graph().as_graph_def() # TF GraphDef Interpreter, load_delegate = ( if not Path(w).is_file(): # if not *.pdmodel model = TritonRemoteModel(url=w) # class names self.__dict__.update(locals()) # assign all variables to self<\/p>\n def forward(self, im, augment=False, visualize=False): if self.pt: # PyTorch if isinstance(y, (list, tuple)): def from_numpy(self, x): def warmup(self, imgsz=(1, 3, 640, 640)): @staticmethod Example: path='path\/to\/model.onnx' -> type=onnx sf = list(export_formats().Suffix) # export suffixes @staticmethod class AutoShape(nn.Module): conf = 0.25 # NMS confidence threshold def __init__(self, model, verbose=True): def _apply(self, fn): to model tensors excluding parameters or registered buffers. @smart_inference_mode() Supports various formats including file, URI, OpenCV, PIL, numpy, torch. dt = (Profile(), Profile(), Profile()) # Pre-process with amp.autocast(autocast): # Post-process return Detections(ims, y, files, dt, self.names, x.shape)<\/p>\n class Detections: def __init__(self, ims, pred, files, times=(0, 0, 0), names=None, shape=None): def _run(self, pprint=False, show=False, save=False, crop=False, render=False, labels=True, save_dir=Path("")): im = Image.fromarray(im.astype(np.uint8)) if isinstance(im, np.ndarray) else im # from np display(im) @TryExcept("Showing images is not supported in this environment") Usage: show(labels=True) def save(self, labels=True, save_dir="runs\/detect\/exp", exist_ok=False): Usage: save(labels=True, save_dir='runs\/detect\/exp', exist_ok=False) def crop(self, save=True, save_dir="runs\/detect\/exp", exist_ok=False): Args: save (bool), save_dir (str), exist_ok (bool). def render(self, labels=True): def pandas(self): Example: print(results.pandas().xyxy[0]). def tolist(self): Example: for result in results.tolist(): def print(self): def __len__(self): def __str__(self): def __repr__(self): class Proto(nn.Module): def __init__(self, c1, c_=256, c2=32): def forward(self, x): class Classify(nn.Module): def __init__( def forward(self, x): # This module is used in RT-DETR and can fuse convolutions during inference for efficiency.<\/p>\n Attributes: References: default_act = nn.ReLU6() # default activation Args: self.bn = nn.BatchNorm2d(num_features=c1) if bn and c2 == c1 and s == 1 else None def forward_fuse(self, x): Args: Returns: def forward(self, x): Args: Returns: def get_equivalent_kernel_bias(self): Returns: @staticmethod Args: Returns: def _fuse_bn_tensor(self, branch): Args: Returns: def fuse_convs(self): self.conv = nn.Conv2d( class ECA(nn.Module): def __init__(self, c1, c2, k_size=3): def forward(self, x): return x * y.expand_as(x) <\/p>\n %%writefile \/kaggle\/working\/yolov5\/models\/yolo.py Usage: import argparse import torch FILE = Path(__file__).resolve() try: class Detect(nn.Module): stride = None # strides computed during build def __init__(self, nc=80, anchors=(), ch=(), inplace=True): def forward(self, x): if not self.training: # inference if isinstance(self, Segment): # (boxes + masks) return x if self.training else (torch.cat(z, 1),) if self.export else (torch.cat(z, 1), x)<\/p>\n def _make_grid(self, nx=20, ny=20, i=0, torch_1_10=check_version(torch.__version__, "1.10.0")): class Segment(Detect): def __init__(self, nc=80, anchors=(), nm=32, npr=256, ch=(), inplace=True): def forward(self, x): class BaseModel(nn.Module): def forward(self, x, profile=False, visualize=False): def _forward_once(self, x, profile=False, visualize=False): def _profile_one_layer(self, m, x, dt): def fuse(self): def info(self, verbose=False, img_size=640): def _apply(self, fn): class DetectionModel(BaseModel): def __init__(self, cfg="yolov5s.yaml", ch=3, nc=None, anchors=None): self.yaml_file = Path(cfg).name # Define model # Build strides, anchors def _forward(x): s = 256 # 2x min stride # Init weights, biases def forward(self, x, augment=False, profile=False, visualize=False): def _forward_augment(self, x): def _descale_pred(self, p, flips, scale, img_size): def _clip_augmented(self, y): def _initialize_biases(self, cf=None): For details see https:\/\/arxiv.org\/abs\/1708.02002 section 3.3. Model = DetectionModel # retain YOLOv5 'Model' class for backwards compatibility<\/p>\n class SegmentationModel(DetectionModel): def __init__(self, cfg="yolov5s-seg.yaml", ch=3, nc=None, anchors=None): class ClassificationModel(BaseModel): def __init__(self, cfg=None, model=None, nc=1000, cutoff=10): def _from_detection_model(self, model, nc=1000, cutoff=10): def _from_yaml(self, cfg): # \u6a21\u578b\u6784\u5efa LOGGER.info(f"{colorstr('activation:')} {act}") # print layers, save, c2 = [], [], ch[-1] # layers, savelist, ch out args = [c1, c2, *args[1:]] m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args) # module if __name__ == "__main__": # Create model # Options elif opt.profile: # profile forward-backward elif opt.test: # test all models else: # report fused model summary \u76f4\u63a5\u8bad\u7ec3\u547d\u4ee4\u5373\u53ef\u5f00\u59cb\u7545\u60f3\u6f2b\u957f\u7684\u7b49\u5f85\u65f6\u523b，\u73b0\u5728\u662f\u6296\u97f3\u65f6\u95f4！！！<\/p>\n !python train.py –data coco128.yaml –cfg yolov5n.yaml –weights '' –epochs 150 –batch-size 64 –img-size 640 –hyp hyp.scratch-low.yaml –device 0 <\/p>\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u9700\u8981\u4e0b\u8f7d\u6307\u5b9a\u6587\u4ef6\u5939\u7684，\u6bd4\u5982\u8bad\u7ec3\u7ed3\u679c，\u73b0\u5728\u538b\u7f29，\u7136\u540e\u5728\u53f3\u4fa7\u9009\u4e2d\u6587\u4ef6，\u53f3\u8fb9\u70b9\u51fb\u4e09\u4e2a\u5c0f\u70b9\u8fdb\u884c\u4e0b\u8f7d：<\/p>\n \u6ca1\u53cd\u5e94\u7684\u8bf7F12\u6293\u53d6\u4e0b\u8f7d\u94fe\u63a5，\u76f4\u63a5\u590d\u5236\u5230\u6d4f\u89c8\u5668\u641c\u7d22\u680f\u5373\u53ef\u4e0b\u8f7d\u3002<\/p>\n import os \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u672c\u6587\u8be6\u7ec6\u4ecb\u7ecd\u4e86\u4f7f\u7528 Kaggel \u514d\u8d39\u670d\u52a1\u5668\u8fdb\u884cYOLOv5\u6a21\u578b\u8bad\u7ec3，\u6574\u4e2a\u6d41\u7a0b\u540c\u6837\u9002\u7528\u4e8e\u5176\u4ed6\u8bad\u7ec3\u6846\u67b6\u3002\u672c\u6587\u8fd8\u63d0\u4f9b\u4e86YOLOv5\u6539\u8fdb\u4ee3\u7801\u793a\u4f8b\u3002<\/p>\n<\/p>\n \u611f\u8c22\u9605\u89c8，\u5982\u679c\u4f60\u559c\u6b22\u8be5\u5185\u5bb9\u7684\u8bdd，\u53ef\u4ee5\u70b9\u8d5e，\u6536\u85cf，\u8f6c\u53d1\u3002\u7531\u4e8e Koro \u80fd\u529b\u6709\u9650，\u6709\u4efb\u4f55\u95ee\u9898\u8bf7\u5728\u8bc4\u8bba\u533a\u5185\u63d0\u51fa，Koro \u770b\u5230\u540e\u7b2c\u4e00\u65f6\u95f4\u56de\u590d\u60a8！！！<\/p>\n \u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb1.1k\u6b21\uff0c\u70b9\u8d5e33\u6b21\uff0c\u6536\u85cf19\u6b21\u3002\u672c\u6587\u8be6\u7ec6\u4ecb\u7ecd\u4e86\u4f7f\u7528 Kaggel \u514d\u8d39\u670d\u52a1\u5668\u8fdb\u884cYOLOv5\u6a21\u578b\u8bad\u7ec3\uff0c\u6574\u4e2a\u6d41\u7a0b\u540c\u6837\u9002\u7528\u4e8e\u5176\u4ed6\u8bad\u7ec3\u6846\u67b6\u3002\u672c\u6587\u8fd8\u63d0\u4f9b\u4e86YOLOv5\u6539\u8fdb\u4ee3\u7801\u793a\u4f8b\u3002<\/p>\n","protected":false},"author":2,"featured_media":33566,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[156,43,44],"topic":[],"class_list":["post-33577","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-yolo","tag-43","tag-44"],"yoast_head":"\n
\n
\n\u9ad8\u6027\u80fd\u4e91\u670d\u52a1\u5668OpenBayes<\/span><\/h2>\n
\nKaggle<\/span><\/h2>\n
\n\n
\n
\u6570\u636e\u96c6\u4e0a\u4f20<\/span><\/h2>\n
\n![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235529-680ec3f1616c5.png\")
<\/p>\n![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235529-680ec3f1b7798.png\")
<\/p>\n![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235530-680ec3f26ce37.png\")
<\/p>\n![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235530-680ec3f299f19.png\")
<\/p>\n![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235530-680ec3f2da47b.png\")
<\/p>\n![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235531-680ec3f33b505.png\")
<\/p>\n\u521b\u5efa\u7f16\u8f91\u5668（NoteBook）<\/span><\/h2>\n
\n<\/p>\n\u7ed1\u5b9a\u6570\u636e\u96c6<\/span><\/h4>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235531-680ec3f3a78fc.png\")
<\/p>\n![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235532-680ec3f4665a1.png\")
<\/p>\n\u914d\u7f6eYOLOv5\u6846\u67b6<\/span><\/h4>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235533-680ec3f527248.png\")
<\/p>\n\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250427235533-680ec3f560528.png\")
<\/p>\n
\nimport os
\nos.chdir('\/kaggle\/working\/yolov5')
\n!ls
\n!pip install -r requirements.txt <\/p>\n\u914d\u7f6e\u6570\u636e\u96c6<\/span><\/span><\/h4>\n
\n# \u4fee\u6539coco128
\npath: \/kaggle\/input\/handsdata
\ntrain: images\/train
\nval: images\/val
\nnc: 1
\nnames: ['Hand']<\/p>\n\u4fee\u6539\u8d85\u53c2\u6570\u6587\u4ef6（\u8fdb\u9636，\u53ef\u9009）<\/span><\/h4>\n
\n# \u4fee\u6539\u8d85\u53c2\u6570\u6587\u4ef6
\nlr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
\nlrf: 0.01 # final OneCycleLR learning rate (lr0 * lrf)
\nmomentum: 0.937 # SGD momentum\/Adam beta1
\nweight_decay: 0.0005 # optimizer weight decay 5e-4
\nwarmup_epochs: 3.0 # warmup epochs (fractions ok)
\nwarmup_momentum: 0.8 # warmup initial momentum
\nwarmup_bias_lr: 0.1 # warmup initial bias lr
\nbox: 0.05 # box loss gain
\ncls: 0.5 # cls loss gain
\ncls_pw: 1.0 # cls BCELoss positive_weight
\nobj: 1.0 # obj loss gain (scale with pixels)
\nobj_pw: 1.0 # obj BCELoss positive_weight
\niou_t: 0.20 # IoU training threshold
\nanchor_t: 4.0 # anchor-multiple threshold
\n# anchors: 3 # anchors per output layer (0 to ignore)
\nfl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
\nhsv_h: 0.015 # image HSV-Hue augmentation (fraction)
\nhsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
\nhsv_v: 0.4 # image HSV-Value augmentation (fraction)
\ndegrees: 0.0 # image rotation (+\/- deg)
\ntranslate: 0.1 # image translation (+\/- fraction)
\nscale: 0.5 # image scale (+\/- gain)
\nshear: 0.0 # image shear (+\/- deg)
\nperspective: 0.0 # image perspective (+\/- fraction), range 0-0.001
\nflipud: 0.0 # image flip up-down (probability)
\nfliplr: 0.5 # image flip left-right (probability)
\nmosaic: 1.0 # image mosaic (probability)
\nmixup: 0.0 # image mixup (probability)
\ncopy_paste: 0.0 # segment copy-paste (probability)<\/p>\n\u4fee\u6539\u6a21\u578b\u7ed3\u6784\u6587\u4ef6（\u8fdb\u9636，\u53ef\u9009）<\/span><\/h4>\n
\n# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
\n# Parameters
\nnc: 1 # number of classes
\ndepth_multiple: 0.33 # model depth multiple
\nwidth_multiple: 0.25 # layer channel multiple
\nanchors:
\n – [10,13, 16,30, 33,23] # P3\/8
\n – [30,61, 62,45, 59,119] # P4\/16
\n – [116,90, 156,198, 373,326] # P5\/32
\nactivation: nn.SiLU()
\n# YOLOv5 v6.0 backbone
\nbackbone:
\n # [from, number, module, args]
\n [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1\/2
\n [-1, 1, Conv, [128, 3, 2]], # 1-P2\/4
\n [-1, 1, C3, [128, 1]], # 2
\n [-1, 1, Conv, [256, 3, 2]], # 3-P3\/8
\n [-1, 1, C3, [256, 1]], # 4
\n [-1, 1, Conv, [512, 3, 2]], # 5-P4\/16
\n [-1, 1, C3, [512, 1]], # 6
\n [-1, 1, Conv, [1024, 3, 2]], # 7-P5\/32
\n [-1, 1, C3, [1024, 1]], # 8
\n [-1, 1, SPPF, [1024, 5]], # 9
\n ]<\/p>\n
\nhead:
\n [[-1, 1, Conv, [512, 1, 1]],
\n [-1, 1, nn.Upsample, [None, 2, 'nearest']],
\n [[-1, 6], 1, Concat, [1]], # cat backbone P4
\n [-1, 1, C3, [512, 1]], # 13<\/p>\n
\n [-1, 1, nn.Upsample, [None, 2, 'nearest']],
\n [[-1, 4], 1, Concat, [1]], # cat backbone P3
\n [-1, 1, C3, [256, 1]], # 17 (P3\/8-small)<\/p>\n
\n [[-1, 13], 1, Concat, [1]], # cat head P4
\n [-1, 1, C3, [512, 1]], # 20 (P4\/16-medium)<\/p>\n
\n [[-1, 9], 1, Concat, [1]], # cat head P5
\n [-1, 1, C3, [1024, 1]], # 23 (P5\/32-large)<\/p>\n
\n ]<\/p>\n\u914d\u7f6e\u6a21\u5757\u8f93\u5165\u53c2\u6570（\u8fdb\u9636，\u53ef\u9009）<\/span><\/h4>\n
\n# \u4fee\u6539 common.py<\/p>\n
\n"""Common modules."""<\/p>\n
\nimport contextlib
\nimport json
\nimport math
\nimport platform
\nimport warnings
\nimport zipfile
\nfrom collections import OrderedDict, namedtuple
\nfrom copy import copy
\nfrom pathlib import Path
\nfrom urllib.parse import urlparse<\/p>\n
\nimport numpy as np
\nimport pandas as pd
\nimport requests
\nimport torch
\nimport torch.nn as nn
\nfrom PIL import Image
\nfrom torch.cuda import amp<\/p>\n
\ntry:
\n import ultralytics<\/p>\n
\nexcept (ImportError, AssertionError):
\n import os<\/p>\n
\n import ultralytics<\/p>\n
\nfrom utils.dataloaders import exif_transpose, letterbox
\nfrom utils.general import (
\n LOGGER,
\n ROOT,
\n Profile,
\n check_requirements,
\n check_suffix,
\n check_version,
\n colorstr,
\n increment_path,
\n is_jupyter,
\n make_divisible,
\n non_max_suppression,
\n scale_boxes,
\n xywh2xyxy,
\n xyxy2xywh,
\n yaml_load,
\n)
\nfrom utils.torch_utils import copy_attr, smart_inference_mode<\/p>\n
\n """
\n Pads kernel to 'same' output shape, adjusting for optional dilation; returns padding size.<\/p>\n
\n """
\n if d > 1:
\n k = d * (k – 1) + 1 if isinstance(k, int) else [d * (x – 1) + 1 for x in k] # actual kernel-size
\n if p is None:
\n p = k \/\/ 2 if isinstance(k, int) else [x \/\/ 2 for x in k] # auto-pad
\n return p<\/p>\n
\n """Applies a convolution, batch normalization, and activation function to an input tensor in a neural network."""<\/p>\n
\n """Initializes a standard convolution layer with optional batch normalization and activation."""
\n super().__init__()
\n self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
\n self.bn = nn.BatchNorm2d(c2)
\n self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()<\/p>\n
\n """Applies a convolution followed by batch normalization and an activation function to the input tensor `x`."""
\n return self.act(self.bn(self.conv(x)))<\/p>\n
\n """Applies a fused convolution and activation function to the input tensor `x`."""
\n return self.act(self.conv(x))<\/p>\n
\n """Implements a depth-wise convolution layer with optional activation for efficient spatial filtering."""<\/p>\n
\n """Initializes a depth-wise convolution layer with optional activation; args: input channels (c1), output
\n channels (c2), kernel size (k), stride (s), dilation (d), and activation flag (act).
\n """
\n super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), d=d, act=act)<\/p>\n
\n """A depth-wise transpose convolutional layer for upsampling in neural networks, particularly in YOLOv5 models."""<\/p>\n
\n """Initializes a depth-wise transpose convolutional layer for YOLOv5; args: input channels (c1), output channels
\n (c2), kernel size (k), stride (s), input padding (p1), output padding (p2).
\n """
\n super().__init__(c1, c2, k, s, p1, p2, groups=math.gcd(c1, c2))<\/p>\n
\n """Transformer layer with multihead attention and linear layers, optimized by removing LayerNorm."""<\/p>\n
\n """
\n Initializes a transformer layer, sans LayerNorm for performance, with multihead attention and linear layers.<\/p>\n
\n """
\n super().__init__()
\n self.q = nn.Linear(c, c, bias=False)
\n self.k = nn.Linear(c, c, bias=False)
\n self.v = nn.Linear(c, c, bias=False)
\n self.ma = nn.MultiheadAttention(embed_dim=c, num_heads=num_heads)
\n self.fc1 = nn.Linear(c, c, bias=False)
\n self.fc2 = nn.Linear(c, c, bias=False)<\/p>\n
\n """Performs forward pass using MultiheadAttention and two linear transformations with residual connections."""
\n x = self.ma(self.q(x), self.k(x), self.v(x))[0] + x
\n x = self.fc2(self.fc1(x)) + x
\n return x<\/p>\n
\n """A Transformer block for vision tasks with convolution, position embeddings, and Transformer layers."""<\/p>\n
\n """Initializes a Transformer block for vision tasks, adapting dimensions if necessary and stacking specified
\n layers.
\n """
\n super().__init__()
\n self.conv = None
\n if c1 != c2:
\n self.conv = Conv(c1, c2)
\n self.linear = nn.Linear(c2, c2) # learnable position embedding
\n self.tr = nn.Sequential(*(TransformerLayer(c2, num_heads) for _ in range(num_layers)))
\n self.c2 = c2<\/p>\n
\n """Processes input through an optional convolution, followed by Transformer layers and position embeddings for
\n object detection.
\n """
\n if self.conv is not None:
\n x = self.conv(x)
\n b, _, w, h = x.shape
\n p = x.flatten(2).permute(2, 0, 1)
\n return self.tr(p + self.linear(p)).permute(1, 2, 0).reshape(b, self.c2, w, h)<\/p>\n
\n """A bottleneck layer with optional shortcut and group convolution for efficient feature extraction."""<\/p>\n
\n """Initializes a standard bottleneck layer with optional shortcut and group convolution, supporting channel
\n expansion.
\n """
\n super().__init__()
\n c_ = int(c2 * e) # hidden channels
\n self.cv1 = Conv(c1, c_, 1, 1)
\n self.cv2 = Conv(c_, c2, 3, 1, g=g)
\n self.add = shortcut and c1 == c2<\/p>\n
\n """Processes input through two convolutions, optionally adds shortcut if channel dimensions match; input is a
\n tensor.
\n """
\n return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))<\/p>\n
\n """CSP bottleneck layer for feature extraction with cross-stage partial connections and optional shortcuts."""<\/p>\n
\n """Initializes CSP bottleneck with optional shortcuts; args: ch_in, ch_out, number of repeats, shortcut bool,
\n groups, expansion.
\n """
\n super().__init__()
\n c_ = int(c2 * e) # hidden channels
\n self.cv1 = Conv(c1, c_, 1, 1)
\n self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False)
\n self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False)
\n self.cv4 = Conv(2 * c_, c2, 1, 1)
\n self.bn = nn.BatchNorm2d(2 * c_) # applied to cat(cv2, cv3)
\n self.act = nn.SiLU()
\n self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))<\/p>\n
\n """Performs forward pass by applying layers, activation, and concatenation on input x, returning feature-
\n enhanced output.
\n """
\n y1 = self.cv3(self.m(self.cv1(x)))
\n y2 = self.cv2(x)
\n return self.cv4(self.act(self.bn(torch.cat((y1, y2), 1))))<\/p>\n
\n """Implements a cross convolution layer with downsampling, expansion, and optional shortcut."""<\/p>\n
\n """
\n Initializes CrossConv with downsampling, expanding, and optionally shortcutting; `c1` input, `c2` output
\n channels.<\/p>\n
\n """
\n super().__init__()
\n c_ = int(c2 * e) # hidden channels
\n self.cv1 = Conv(c1, c_, (1, k), (1, s))
\n self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
\n self.add = shortcut and c1 == c2<\/p>\n
\n """Performs feature sampling, expanding, and applies shortcut if channels match; expects `x` input tensor."""
\n return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))<\/p>\n
\n """Implements a CSP Bottleneck module with three convolutions for enhanced feature extraction in neural networks."""<\/p>\n
\n """Initializes C3 module with options for channel count, bottleneck repetition, shortcut usage, group
\n convolutions, and expansion.
\n """
\n super().__init__()
\n c_ = int(c2 * e) # hidden channels
\n self.cv1 = Conv(c1, c_, 1, 1)
\n self.cv2 = Conv(c1, c_, 1, 1)
\n self.cv3 = Conv(2 * c_, c2, 1) # optional act=FReLU(c2)
\n self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))<\/p>\n
\n """Performs forward propagation using concatenated outputs from two convolutions and a Bottleneck sequence."""
\n return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))<\/p>\n
\n """Extends the C3 module with cross-convolutions for enhanced feature extraction in neural networks."""<\/p>\n
\n """Initializes C3x module with cross-convolutions, extending C3 with customizable channel dimensions, groups,
\n and expansion.
\n """
\n super().__init__(c1, c2, n, shortcut, g, e)
\n c_ = int(c2 * e)
\n self.m = nn.Sequential(*(CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)))<\/p>\n
\n """C3 module with TransformerBlock for enhanced feature extraction in object detection models."""<\/p>\n
\n """Initializes C3 module with TransformerBlock for enhanced feature extraction, accepts channel sizes, shortcut
\n config, group, and expansion.
\n """
\n super().__init__(c1, c2, n, shortcut, g, e)
\n c_ = int(c2 * e)
\n self.m = TransformerBlock(c_, c_, 4, n)<\/p>\n
\n """Extends the C3 module with an SPP layer for enhanced spatial feature extraction and customizable channels."""<\/p>\n
\n """Initializes a C3 module with SPP layer for advanced spatial feature extraction, given channel sizes, kernel
\n sizes, shortcut, group, and expansion ratio.
\n """
\n super().__init__(c1, c2, n, shortcut, g, e)
\n c_ = int(c2 * e)
\n self.m = SPP(c_, c_, k)<\/p>\n
\n """Implements a C3 module with Ghost Bottlenecks for efficient feature extraction in YOLOv5."""<\/p>\n
\n """Initializes YOLOv5's C3 module with Ghost Bottlenecks for efficient feature extraction."""
\n super().__init__(c1, c2, n, shortcut, g, e)
\n c_ = int(c2 * e) # hidden channels
\n self.m = nn.Sequential(*(GhostBottleneck(c_, c_) for _ in range(n)))<\/p>\n
\n """Implements Spatial Pyramid Pooling (SPP) for feature extraction, ref: https:\/\/arxiv.org\/abs\/1406.4729."""<\/p>\n
\n """Initializes SPP layer with Spatial Pyramid Pooling, ref: https:\/\/arxiv.org\/abs\/1406.4729, args: c1 (input channels), c2 (output channels), k (kernel sizes)."""
\n super().__init__()
\n c_ = c1 \/\/ 2 # hidden channels
\n self.cv1 = Conv(c1, c_, 1, 1)
\n self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
\n self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x \/\/ 2) for x in k])<\/p>\n
\n """Applies convolution and max pooling layers to the input tensor `x`, concatenates results, and returns output
\n tensor.
\n """
\n x = self.cv1(x)
\n with warnings.catch_warnings():
\n warnings.simplefilter("ignore") # suppress torch 1.9.0 max_pool2d() warning
\n return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))<\/p>\n
\n """Implements a fast Spatial Pyramid Pooling (SPPF) layer for efficient feature extraction in YOLOv5 models."""<\/p>\n
\n """
\n Initializes YOLOv5 SPPF layer with given channels and kernel size for YOLOv5 model, combining convolution and
\n max pooling.<\/p>\n
\n """
\n super().__init__()
\n c_ = c1 \/\/ 2 # hidden channels
\n self.cv1 = Conv(c1, c_, 1, 1)
\n self.cv2 = Conv(c_ * 4, c2, 1, 1)
\n self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k \/\/ 2)<\/p>\n
\n """Processes input through a series of convolutions and max pooling operations for feature extraction."""
\n x = self.cv1(x)
\n with warnings.catch_warnings():
\n warnings.simplefilter("ignore") # suppress torch 1.9.0 max_pool2d() warning
\n y1 = self.m(x)
\n y2 = self.m(y1)
\n return self.cv2(torch.cat((x, y1, y2, self.m(y2)), 1))<\/p>\n
\n """Focuses spatial information into channel space using slicing and convolution for efficient feature extraction."""<\/p>\n
\n """Initializes Focus module to concentrate width-height info into channel space with configurable convolution
\n parameters.
\n """
\n super().__init__()
\n self.conv = Conv(c1 * 4, c2, k, s, p, g, act=act)
\n # self.contract = Contract(gain=2)<\/p>\n
\n """Processes input through Focus mechanism, reshaping (b,c,w,h) to (b,4c,w\/2,h\/2) then applies convolution."""
\n return self.conv(torch.cat((x[…, ::2, ::2], x[…, 1::2, ::2], x[…, ::2, 1::2], x[…, 1::2, 1::2]), 1))
\n # return self.conv(self.contract(x))<\/p>\n
\n """Implements Ghost Convolution for efficient feature extraction, see https:\/\/github.com\/huawei-noah\/ghostnet."""<\/p>\n
\n """Initializes GhostConv with in\/out channels, kernel size, stride, groups, and activation; halves out channels
\n for efficiency.
\n """
\n super().__init__()
\n c_ = c2 \/\/ 2 # hidden channels
\n self.cv1 = Conv(c1, c_, k, s, None, g, act=act)
\n self.cv2 = Conv(c_, c_, 5, 1, None, c_, act=act)<\/p>\n
\n """Performs forward pass, concatenating outputs of two convolutions on input `x`: shape (B,C,H,W)."""
\n y = self.cv1(x)
\n return torch.cat((y, self.cv2(y)), 1)<\/p>\n
\n """Efficient bottleneck layer using Ghost Convolutions, see https:\/\/github.com\/huawei-noah\/ghostnet."""<\/p>\n
\n """Initializes GhostBottleneck with ch_in `c1`, ch_out `c2`, kernel size `k`, stride `s`; see https:\/\/github.com\/huawei-noah\/ghostnet."""
\n super().__init__()
\n c_ = c2 \/\/ 2
\n self.conv = nn.Sequential(
\n GhostConv(c1, c_, 1, 1), # pw
\n DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(), # dw
\n GhostConv(c_, c2, 1, 1, act=False),
\n ) # pw-linear
\n self.shortcut = (
\n nn.Sequential(DWConv(c1, c1, k, s, act=False), Conv(c1, c2, 1, 1, act=False)) if s == 2 else nn.Identity()
\n )<\/p>\n
\n """Processes input through conv and shortcut layers, returning their summed output."""
\n return self.conv(x) + self.shortcut(x)<\/p>\n
\n """Contracts spatial dimensions into channel dimensions for efficient processing in neural networks."""<\/p>\n
\n """Initializes a layer to contract spatial dimensions (width-height) into channels, e.g., input shape
\n (1,64,80,80) to (1,256,40,40).
\n """
\n super().__init__()
\n self.gain = gain<\/p>\n
\n """Processes input tensor to expand channel dimensions by contracting spatial dimensions, yielding output shape
\n `(b, c*s*s, h\/\/s, w\/\/s)`.
\n """
\n b, c, h, w = x.size() # assert (h \/ s == 0) and (W \/ s == 0), 'Indivisible gain'
\n s = self.gain
\n x = x.view(b, c, h \/\/ s, s, w \/\/ s, s) # x(1,64,40,2,40,2)
\n x = x.permute(0, 3, 5, 1, 2, 4).contiguous() # x(1,2,2,64,40,40)
\n return x.view(b, c * s * s, h \/\/ s, w \/\/ s) # x(1,256,40,40)<\/p>\n
\n """Expands spatial dimensions by redistributing channels, e.g., from (1,64,80,80) to (1,16,160,160)."""<\/p>\n
\n """
\n Initializes the Expand module to increase spatial dimensions by redistributing channels, with an optional gain
\n factor.<\/p>\n
\n """
\n super().__init__()
\n self.gain = gain<\/p>\n
\n """Processes input tensor x to expand spatial dimensions by redistributing channels, requiring C \/ gain^2 ==
\n 0.
\n """
\n b, c, h, w = x.size() # assert C \/ s ** 2 == 0, 'Indivisible gain'
\n s = self.gain
\n x = x.view(b, s, s, c \/\/ s**2, h, w) # x(1,2,2,16,80,80)
\n x = x.permute(0, 3, 4, 1, 5, 2).contiguous() # x(1,16,80,2,80,2)
\n return x.view(b, c \/\/ s**2, h * s, w * s) # x(1,16,160,160)<\/p>\n
\n """Concatenates tensors along a specified dimension for efficient tensor manipulation in neural networks."""<\/p>\n
\n """Initializes a Concat module to concatenate tensors along a specified dimension."""
\n super().__init__()
\n self.d = dimension<\/p>\n
\n """Concatenates a list of tensors along a specified dimension; `x` is a list of tensors, `dimension` is an
\n int.
\n """
\n return torch.cat(x, self.d)<\/p>\n
\n """YOLOv5 MultiBackend class for inference on various backends including PyTorch, ONNX, TensorRT, and more."""<\/p>\n
\n """Initializes DetectMultiBackend with support for various inference backends, including PyTorch and ONNX."""
\n # PyTorch: weights = *.pt
\n # TorchScript: *.torchscript
\n # ONNX Runtime: *.onnx
\n # ONNX OpenCV DNN: *.onnx –dnn
\n # OpenVINO: *_openvino_model
\n # CoreML: *.mlpackage
\n # TensorRT: *.engine
\n # TensorFlow SavedModel: *_saved_model
\n # TensorFlow GraphDef: *.pb
\n # TensorFlow Lite: *.tflite
\n # TensorFlow Edge TPU: *_edgetpu.tflite
\n # PaddlePaddle: *_paddle_model
\n from models.experimental import attempt_download, attempt_load # scoped to avoid circular import<\/p>\n
\n w = str(weights[0] if isinstance(weights, list) else weights)
\n pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle, triton = self._model_type(w)
\n fp16 &= pt or jit or onnx or engine or triton # FP16
\n nhwc = coreml or saved_model or pb or tflite or edgetpu # BHWC formats (vs torch BCWH)
\n stride = 32 # default stride
\n cuda = torch.cuda.is_available() and device.type != "cpu" # use CUDA
\n if not (pt or triton):
\n w = attempt_download(w) # download if not local<\/p>\n
\n model = attempt_load(weights if isinstance(weights, list) else w, device=device, inplace=True, fuse=fuse)
\n stride = max(int(model.stride.max()), 32) # model stride
\n names = model.module.names if hasattr(model, "module") else model.names # get class names
\n model.half() if fp16 else model.float()
\n self.model = model # explicitly assign for to(), cpu(), cuda(), half()
\n elif jit: # TorchScript
\n LOGGER.info(f"Loading {w} for TorchScript inference…")
\n extra_files = {"config.txt": ""} # model metadata
\n model = torch.jit.load(w, _extra_files=extra_files, map_location=device)
\n model.half() if fp16 else model.float()
\n if extra_files["config.txt"]: # load metadata dict
\n d = json.loads(
\n extra_files["config.txt"],
\n object_hook=lambda d: {int(k) if k.isdigit() else k: v for k, v in d.items()},
\n )
\n stride, names = int(d["stride"]), d["names"]
\n elif dnn: # ONNX OpenCV DNN
\n LOGGER.info(f"Loading {w} for ONNX OpenCV DNN inference…")
\n check_requirements("opencv-python>=4.5.4")
\n net = cv2.dnn.readNetFromONNX(w)
\n elif onnx: # ONNX Runtime
\n LOGGER.info(f"Loading {w} for ONNX Runtime inference…")
\n check_requirements(("onnx", "onnxruntime-gpu" if cuda else "onnxruntime"))
\n import onnxruntime<\/p>\n
\n session = onnxruntime.InferenceSession(w, providers=providers)
\n output_names = [x.name for x in session.get_outputs()]
\n meta = session.get_modelmeta().custom_metadata_map # metadata
\n if "stride" in meta:
\n stride, names = int(meta["stride"]), eval(meta["names"])
\n elif xml: # OpenVINO
\n LOGGER.info(f"Loading {w} for OpenVINO inference…")
\n check_requirements("openvino>=2023.0") # requires openvino-dev: https:\/\/pypi.org\/project\/openvino-dev\/
\n from openvino.runtime import Core, Layout, get_batch<\/p>\n
\n if not Path(w).is_file(): # if not *.xml
\n w = next(Path(w).glob("*.xml")) # get *.xml file from *_openvino_model dir
\n ov_model = core.read_model(model=w, weights=Path(w).with_suffix(".bin"))
\n if ov_model.get_parameters()[0].get_layout().empty:
\n ov_model.get_parameters()[0].set_layout(Layout("NCHW"))
\n batch_dim = get_batch(ov_model)
\n if batch_dim.is_static:
\n batch_size = batch_dim.get_length()
\n ov_compiled_model = core.compile_model(ov_model, device_name="AUTO") # AUTO selects best available device
\n stride, names = self._load_metadata(Path(w).with_suffix(".yaml")) # load metadata
\n elif engine: # TensorRT
\n LOGGER.info(f"Loading {w} for TensorRT inference…")
\n import tensorrt as trt # https:\/\/developer.nvidia.com\/nvidia-tensorrt-download<\/p>\n
\n if device.type == "cpu":
\n device = torch.device("cuda:0")
\n Binding = namedtuple("Binding", ("name", "dtype", "shape", "data", "ptr"))
\n logger = trt.Logger(trt.Logger.INFO)
\n with open(w, "rb") as f, trt.Runtime(logger) as runtime:
\n model = runtime.deserialize_cuda_engine(f.read())
\n context = model.create_execution_context()
\n bindings = OrderedDict()
\n output_names = []
\n fp16 = False # default updated below
\n dynamic = False
\n is_trt10 = not hasattr(model, "num_bindings")
\n num = range(model.num_io_tensors) if is_trt10 else range(model.num_bindings)
\n for i in num:
\n if is_trt10:
\n name = model.get_tensor_name(i)
\n dtype = trt.nptype(model.get_tensor_dtype(name))
\n is_input = model.get_tensor_mode(name) == trt.TensorIOMode.INPUT
\n if is_input:
\n if -1 in tuple(model.get_tensor_shape(name)): # dynamic
\n dynamic = True
\n context.set_input_shape(name, tuple(model.get_profile_shape(name, 0)[2]))
\n if dtype == np.float16:
\n fp16 = True
\n else: # output
\n output_names.append(name)
\n shape = tuple(context.get_tensor_shape(name))
\n else:
\n name = model.get_binding_name(i)
\n dtype = trt.nptype(model.get_binding_dtype(i))
\n if model.binding_is_input(i):
\n if -1 in tuple(model.get_binding_shape(i)): # dynamic
\n dynamic = True
\n context.set_binding_shape(i, tuple(model.get_profile_shape(0, i)[2]))
\n if dtype == np.float16:
\n fp16 = True
\n else: # output
\n output_names.append(name)
\n shape = tuple(context.get_binding_shape(i))
\n im = torch.from_numpy(np.empty(shape, dtype=dtype)).to(device)
\n bindings[name] = Binding(name, dtype, shape, im, int(im.data_ptr()))
\n binding_addrs = OrderedDict((n, d.ptr) for n, d in bindings.items())
\n batch_size = bindings["images"].shape[0] # if dynamic, this is instead max batch size
\n elif coreml: # CoreML
\n LOGGER.info(f"Loading {w} for CoreML inference…")
\n import coremltools as ct<\/p>\n
\n elif saved_model: # TF SavedModel
\n LOGGER.info(f"Loading {w} for TensorFlow SavedModel inference…")
\n import tensorflow as tf<\/p>\n
\n model = tf.keras.models.load_model(w) if keras else tf.saved_model.load(w)
\n elif pb: # GraphDef https:\/\/www.tensorflow.org\/guide\/migrate#a_graphpb_or_graphpbtxt
\n LOGGER.info(f"Loading {w} for TensorFlow GraphDef inference…")
\n import tensorflow as tf<\/p>\n
\n """Wraps a TensorFlow GraphDef for inference, returning a pruned function."""
\n x = tf.compat.v1.wrap_function(lambda: tf.compat.v1.import_graph_def(gd, name=""), []) # wrapped
\n ge = x.graph.as_graph_element
\n return x.prune(tf.nest.map_structure(ge, inputs), tf.nest.map_structure(ge, outputs))<\/p>\n
\n """Generates a sorted list of graph outputs excluding NoOp nodes and inputs, formatted as '<name>:0'."""
\n name_list, input_list = [], []
\n for node in gd.node: # tensorflow.core.framework.node_def_pb2.NodeDef
\n name_list.append(node.name)
\n input_list.extend(node.input)
\n return sorted(f"{x}:0" for x in list(set(name_list) – set(input_list)) if not x.startswith("NoOp"))<\/p>\n
\n with open(w, "rb") as f:
\n gd.ParseFromString(f.read())
\n frozen_func = wrap_frozen_graph(gd, inputs="x:0", outputs=gd_outputs(gd))
\n elif tflite or edgetpu: # https:\/\/www.tensorflow.org\/lite\/guide\/python#install_tensorflow_lite_for_python
\n try: # https:\/\/coral.ai\/docs\/edgetpu\/tflite-python\/#update-existing-tf-lite-code-for-the-edge-tpu
\n from tflite_runtime.interpreter import Interpreter, load_delegate
\n except ImportError:
\n import tensorflow as tf<\/p>\n
\n tf.lite.Interpreter,
\n tf.lite.experimental.load_delegate,
\n )
\n if edgetpu: # TF Edge TPU https:\/\/coral.ai\/software\/#edgetpu-runtime
\n LOGGER.info(f"Loading {w} for TensorFlow Lite Edge TPU inference…")
\n delegate = {"Linux": "libedgetpu.so.1", "Darwin": "libedgetpu.1.dylib", "Windows": "edgetpu.dll"}[
\n platform.system()
\n ]
\n interpreter = Interpreter(model_path=w, experimental_delegates=[load_delegate(delegate)])
\n else: # TFLite
\n LOGGER.info(f"Loading {w} for TensorFlow Lite inference…")
\n interpreter = Interpreter(model_path=w) # load TFLite model
\n interpreter.allocate_tensors() # allocate
\n input_details = interpreter.get_input_details() # inputs
\n output_details = interpreter.get_output_details() # outputs
\n # load metadata
\n with contextlib.suppress(zipfile.BadZipFile):
\n with zipfile.ZipFile(w, "r") as model:
\n meta_file = model.namelist()[0]
\n meta = ast.literal_eval(model.read(meta_file).decode("utf-8"))
\n stride, names = int(meta["stride"]), meta["names"]
\n elif tfjs: # TF.js
\n raise NotImplementedError("ERROR: YOLOv5 TF.js inference is not supported")
\n elif paddle: # PaddlePaddle
\n LOGGER.info(f"Loading {w} for PaddlePaddle inference…")
\n check_requirements("paddlepaddle-gpu" if cuda else "paddlepaddle")
\n import paddle.inference as pdi<\/p>\n
\n w = next(Path(w).rglob("*.pdmodel")) # get *.pdmodel file from *_paddle_model dir
\n weights = Path(w).with_suffix(".pdiparams")
\n config = pdi.Config(str(w), str(weights))
\n if cuda:
\n config.enable_use_gpu(memory_pool_init_size_mb=2048, device_id=0)
\n predictor = pdi.create_predictor(config)
\n input_handle = predictor.get_input_handle(predictor.get_input_names()[0])
\n output_names = predictor.get_output_names()
\n elif triton: # NVIDIA Triton Inference Server
\n LOGGER.info(f"Using {w} as Triton Inference Server…")
\n check_requirements("tritonclient[all]")
\n from utils.triton import TritonRemoteModel<\/p>\n
\n nhwc = model.runtime.startswith("tensorflow")
\n else:
\n raise NotImplementedError(f"ERROR: {w} is not a supported format")<\/p>\n
\n if "names" not in locals():
\n names = yaml_load(data)["names"] if data else {i: f"class{i}" for i in range(999)}
\n if names[0] == "n01440764" and len(names) == 1000: # ImageNet
\n names = yaml_load(ROOT \/ "data\/ImageNet.yaml")["names"] # human-readable names<\/p>\n
\n """Performs YOLOv5 inference on input images with options for augmentation and visualization."""
\n b, ch, h, w = im.shape # batch, channel, height, width
\n if self.fp16 and im.dtype != torch.float16:
\n im = im.half() # to FP16
\n if self.nhwc:
\n im = im.permute(0, 2, 3, 1) # torch BCHW to numpy BHWC shape(1,320,192,3)<\/p>\n
\n y = self.model(im, augment=augment, visualize=visualize) if augment or visualize else self.model(im)
\n elif self.jit: # TorchScript
\n y = self.model(im)
\n elif self.dnn: # ONNX OpenCV DNN
\n im = im.cpu().numpy() # torch to numpy
\n self.net.setInput(im)
\n y = self.net.forward()
\n elif self.onnx: # ONNX Runtime
\n im = im.cpu().numpy() # torch to numpy
\n y = self.session.run(self.output_names, {self.session.get_inputs()[0].name: im})
\n elif self.xml: # OpenVINO
\n im = im.cpu().numpy() # FP32
\n y = list(self.ov_compiled_model(im).values())
\n elif self.engine: # TensorRT
\n if self.dynamic and im.shape != self.bindings["images"].shape:
\n i = self.model.get_binding_index("images")
\n self.context.set_binding_shape(i, im.shape) # reshape if dynamic
\n self.bindings["images"] = self.bindings["images"]._replace(shape=im.shape)
\n for name in self.output_names:
\n i = self.model.get_binding_index(name)
\n self.bindings[name].data.resize_(tuple(self.context.get_binding_shape(i)))
\n s = self.bindings["images"].shape
\n assert im.shape == s, f"input size {im.shape} {'>' if self.dynamic else 'not equal to'} max model size {s}"
\n self.binding_addrs["images"] = int(im.data_ptr())
\n self.context.execute_v2(list(self.binding_addrs.values()))
\n y = [self.bindings[x].data for x in sorted(self.output_names)]
\n elif self.coreml: # CoreML
\n im = im.cpu().numpy()
\n im = Image.fromarray((im[0] * 255).astype("uint8"))
\n # im = im.resize((192, 320), Image.BILINEAR)
\n y = self.model.predict({"image": im}) # coordinates are xywh normalized
\n if "confidence" in y:
\n box = xywh2xyxy(y["coordinates"] * [[w, h, w, h]]) # xyxy pixels
\n conf, cls = y["confidence"].max(1), y["confidence"].argmax(1).astype(np.float)
\n y = np.concatenate((box, conf.reshape(-1, 1), cls.reshape(-1, 1)), 1)
\n else:
\n y = list(reversed(y.values())) # reversed for segmentation models (pred, proto)
\n elif self.paddle: # PaddlePaddle
\n im = im.cpu().numpy().astype(np.float32)
\n self.input_handle.copy_from_cpu(im)
\n self.predictor.run()
\n y = [self.predictor.get_output_handle(x).copy_to_cpu() for x in self.output_names]
\n elif self.triton: # NVIDIA Triton Inference Server
\n y = self.model(im)
\n else: # TensorFlow (SavedModel, GraphDef, Lite, Edge TPU)
\n im = im.cpu().numpy()
\n if self.saved_model: # SavedModel
\n y = self.model(im, training=False) if self.keras else self.model(im)
\n elif self.pb: # GraphDef
\n y = self.frozen_func(x=self.tf.constant(im))
\n else: # Lite or Edge TPU
\n input = self.input_details[0]
\n int8 = input["dtype"] == np.uint8 # is TFLite quantized uint8 model
\n if int8:
\n scale, zero_point = input["quantization"]
\n im = (im \/ scale + zero_point).astype(np.uint8) # de-scale
\n self.interpreter.set_tensor(input["index"], im)
\n self.interpreter.invoke()
\n y = []
\n for output in self.output_details:
\n x = self.interpreter.get_tensor(output["index"])
\n if int8:
\n scale, zero_point = output["quantization"]
\n x = (x.astype(np.float32) – zero_point) * scale # re-scale
\n y.append(x)
\n if len(y) == 2 and len(y[1].shape) != 4:
\n y = list(reversed(y))
\n y = [x if isinstance(x, np.ndarray) else x.numpy() for x in y]
\n y[0][…, :4] *= [w, h, w, h] # xywh normalized to pixels<\/p>\n
\n return self.from_numpy(y[0]) if len(y) == 1 else [self.from_numpy(x) for x in y]
\n else:
\n return self.from_numpy(y)<\/p>\n
\n """Converts a NumPy array to a torch tensor, maintaining device compatibility."""
\n return torch.from_numpy(x).to(self.device) if isinstance(x, np.ndarray) else x<\/p>\n
\n """Performs a single inference warmup to initialize model weights, accepting an `imgsz` tuple for image size."""
\n warmup_types = self.pt, self.jit, self.onnx, self.engine, self.saved_model, self.pb, self.triton
\n if any(warmup_types) and (self.device.type != "cpu" or self.triton):
\n im = torch.empty(*imgsz, dtype=torch.half if self.fp16 else torch.float, device=self.device) # input
\n for _ in range(2 if self.jit else 1): #
\n self.forward(im) # warmup<\/p>\n
\n def _model_type(p="path\/to\/model.pt"):
\n """
\n Determines model type from file path or URL, supporting various export formats.<\/p>\n
\n """
\n # types = [pt, jit, onnx, xml, engine, coreml, saved_model, pb, tflite, edgetpu, tfjs, paddle]
\n from export import export_formats
\n from utils.downloads import is_url<\/p>\n
\n if not is_url(p, check=False):
\n check_suffix(p, sf) # checks
\n url = urlparse(p) # if url may be Triton inference server
\n types = [s in Path(p).name for s in sf]
\n types[8] &= not types[9] # tflite &= not edgetpu
\n triton = not any(types) and all([any(s in url.scheme for s in ["http", "grpc"]), url.netloc])
\n return types + [triton]<\/p>\n
\n def _load_metadata(f=Path("path\/to\/meta.yaml")):
\n """Loads metadata from a YAML file, returning strides and names if the file exists, otherwise `None`."""
\n if f.exists():
\n d = yaml_load(f)
\n return d["stride"], d["names"] # assign stride, names
\n return None, None<\/p>\n
\n """AutoShape class for robust YOLOv5 inference with preprocessing, NMS, and support for various input formats."""<\/p>\n
\n iou = 0.45 # NMS IoU threshold
\n agnostic = False # NMS class-agnostic
\n multi_label = False # NMS multiple labels per box
\n classes = None # (optional list) filter by class, i.e. = [0, 15, 16] for COCO persons, cats and dogs
\n max_det = 1000 # maximum number of detections per image
\n amp = False # Automatic Mixed Precision (AMP) inference<\/p>\n
\n """Initializes YOLOv5 model for inference, setting up attributes and preparing model for evaluation."""
\n super().__init__()
\n if verbose:
\n LOGGER.info("Adding AutoShape… ")
\n copy_attr(self, model, include=("yaml", "nc", "hyp", "names", "stride", "abc"), exclude=()) # copy attributes
\n self.dmb = isinstance(model, DetectMultiBackend) # DetectMultiBackend() instance
\n self.pt = not self.dmb or model.pt # PyTorch model
\n self.model = model.eval()
\n if self.pt:
\n m = self.model.model.model[-1] if self.dmb else self.model.model[-1] # Detect()
\n m.inplace = False # Detect.inplace=False for safe multithread inference
\n m.export = True # do not output loss values<\/p>\n
\n """
\n Applies to(), cpu(), cuda(), half() etc.<\/p>\n
\n """
\n self = super()._apply(fn)
\n if self.pt:
\n m = self.model.model.model[-1] if self.dmb else self.model.model[-1] # Detect()
\n m.stride = fn(m.stride)
\n m.grid = list(map(fn, m.grid))
\n if isinstance(m.anchor_grid, list):
\n m.anchor_grid = list(map(fn, m.anchor_grid))
\n return self<\/p>\n
\n def forward(self, ims, size=640, augment=False, profile=False):
\n """
\n Performs inference on inputs with optional augment & profiling.<\/p>\n
\n """
\n # For size(height=640, width=1280), RGB images example inputs are:
\n # file: ims = 'data\/images\/zidane.jpg' # str or PosixPath
\n # URI: = 'https:\/\/ultralytics.com\/images\/zidane.jpg'
\n # OpenCV: = cv2.imread('image.jpg')[:,:,::-1] # HWC BGR to RGB x(640,1280,3)
\n # PIL: = Image.open('image.jpg') or ImageGrab.grab() # HWC x(640,1280,3)
\n # numpy: = np.zeros((640,1280,3)) # HWC
\n # torch: = torch.zeros(16,3,320,640) # BCHW (scaled to size=640, 0-1 values)
\n # multiple: = [Image.open('image1.jpg'), Image.open('image2.jpg'), …] # list of images<\/p>\n
\n with dt[0]:
\n if isinstance(size, int): # expand
\n size = (size, size)
\n p = next(self.model.parameters()) if self.pt else torch.empty(1, device=self.model.device) # param
\n autocast = self.amp and (p.device.type != "cpu") # Automatic Mixed Precision (AMP) inference
\n if isinstance(ims, torch.Tensor): # torch
\n with amp.autocast(autocast):
\n return self.model(ims.to(p.device).type_as(p), augment=augment) # inference<\/p>\n
\n n, ims = (len(ims), list(ims)) if isinstance(ims, (list, tuple)) else (1, [ims]) # number, list of images
\n shape0, shape1, files = [], [], [] # image and inference shapes, filenames
\n for i, im in enumerate(ims):
\n f = f"image{i}" # filename
\n if isinstance(im, (str, Path)): # filename or uri
\n im, f = Image.open(requests.get(im, stream=True).raw if str(im).startswith("http") else im), im
\n im = np.asarray(exif_transpose(im))
\n elif isinstance(im, Image.Image): # PIL Image
\n im, f = np.asarray(exif_transpose(im)), getattr(im, "filename", f) or f
\n files.append(Path(f).with_suffix(".jpg").name)
\n if im.shape[0] < 5: # image in CHW
\n im = im.transpose((1, 2, 0)) # reverse dataloader .transpose(2, 0, 1)
\n im = im[…, :3] if im.ndim == 3 else cv2.cvtColor(im, cv2.COLOR_GRAY2BGR) # enforce 3ch input
\n s = im.shape[:2] # HWC
\n shape0.append(s) # image shape
\n g = max(size) \/ max(s) # gain
\n shape1.append([int(y * g) for y in s])
\n ims[i] = im if im.data.contiguous else np.ascontiguousarray(im) # update
\n shape1 = [make_divisible(x, self.stride) for x in np.array(shape1).max(0)] # inf shape
\n x = [letterbox(im, shape1, auto=False)[0] for im in ims] # pad
\n x = np.ascontiguousarray(np.array(x).transpose((0, 3, 1, 2))) # stack and BHWC to BCHW
\n x = torch.from_numpy(x).to(p.device).type_as(p) \/ 255 # uint8 to fp16\/32<\/p>\n
\n # Inference
\n with dt[1]:
\n y = self.model(x, augment=augment) # forward<\/p>\n
\n with dt[2]:
\n y = non_max_suppression(
\n y if self.dmb else y[0],
\n self.conf,
\n self.iou,
\n self.classes,
\n self.agnostic,
\n self.multi_label,
\n max_det=self.max_det,
\n ) # NMS
\n for i in range(n):
\n scale_boxes(shape1, y[i][:, :4], shape0[i])<\/p>\n
\n """Manages YOLOv5 detection results with methods for visualization, saving, cropping, and exporting detections."""<\/p>\n
\n """Initializes the YOLOv5 Detections class with image info, predictions, filenames, timing and normalization."""
\n super().__init__()
\n d = pred[0].device # device
\n gn = [torch.tensor([*(im.shape[i] for i in [1, 0, 1, 0]), 1, 1], device=d) for im in ims] # normalizations
\n self.ims = ims # list of images as numpy arrays
\n self.pred = pred # list of tensors pred[0] = (xyxy, conf, cls)
\n self.names = names # class names
\n self.files = files # image filenames
\n self.times = times # profiling times
\n self.xyxy = pred # xyxy pixels
\n self.xywh = [xyxy2xywh(x) for x in pred] # xywh pixels
\n self.xyxyn = [x \/ g for x, g in zip(self.xyxy, gn)] # xyxy normalized
\n self.xywhn = [x \/ g for x, g in zip(self.xywh, gn)] # xywh normalized
\n self.n = len(self.pred) # number of images (batch size)
\n self.t = tuple(x.t \/ self.n * 1e3 for x in times) # timestamps (ms)
\n self.s = tuple(shape) # inference BCHW shape<\/p>\n
\n """Executes model predictions, displaying and\/or saving outputs with optional crops and labels."""
\n s, crops = "", []
\n for i, (im, pred) in enumerate(zip(self.ims, self.pred)):
\n s += f"\\\\nimage {i + 1}\/{len(self.pred)}: {im.shape[0]}x{im.shape[1]} " # string
\n if pred.shape[0]:
\n for c in pred[:, -1].unique():
\n n = (pred[:, -1] == c).sum() # detections per class
\n s += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, " # add to string
\n s = s.rstrip(", ")
\n if show or save or render or crop:
\n annotator = Annotator(im, example=str(self.names))
\n for *box, conf, cls in reversed(pred): # xyxy, confidence, class
\n label = f"{self.names[int(cls)]} {conf:.2f}"
\n if crop:
\n file = save_dir \/ "crops" \/ self.names[int(cls)] \/ self.files[i] if save else None
\n crops.append(
\n {
\n "box": box,
\n "conf": conf,
\n "cls": cls,
\n "label": label,
\n "im": save_one_box(box, im, file=file, save=save),
\n }
\n )
\n else: # all others
\n annotator.box_label(box, label if labels else "", color=colors(cls))
\n im = annotator.im
\n else:
\n s += "(no detections)"<\/p>\n
\n if show:
\n if is_jupyter():
\n from IPython.display import display<\/p>\n
\n else:
\n im.show(self.files[i])
\n if save:
\n f = self.files[i]
\n im.save(save_dir \/ f) # save
\n if i == self.n – 1:
\n LOGGER.info(f"Saved {self.n} image{'s' * (self.n > 1)} to {colorstr('bold', save_dir)}")
\n if render:
\n self.ims[i] = np.asarray(im)
\n if pprint:
\n s = s.lstrip("\\\\n")
\n return f"{s}\\\\nSpeed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {self.s}" % self.t
\n if crop:
\n if save:
\n LOGGER.info(f"Saved results to {save_dir}\\\\n")
\n return crops<\/p>\n
\n def show(self, labels=True):
\n """
\n Displays detection results with optional labels.<\/p>\n
\n """
\n self._run(show=True, labels=labels) # show results<\/p>\n
\n """
\n Saves detection results with optional labels to a specified directory.<\/p>\n
\n """
\n save_dir = increment_path(save_dir, exist_ok, mkdir=True) # increment save_dir
\n self._run(save=True, labels=labels, save_dir=save_dir) # save results<\/p>\n
\n """
\n Crops detection results, optionally saves them to a directory.<\/p>\n
\n """
\n save_dir = increment_path(save_dir, exist_ok, mkdir=True) if save else None
\n return self._run(crop=True, save=save, save_dir=save_dir) # crop results<\/p>\n
\n """Renders detection results with optional labels on images; args: labels (bool) indicating label inclusion."""
\n self._run(render=True, labels=labels) # render results
\n return self.ims<\/p>\n
\n """
\n Returns detections as pandas DataFrames for various box formats (xyxy, xyxyn, xywh, xywhn).<\/p>\n
\n """
\n new = copy(self) # return copy
\n ca = "xmin", "ymin", "xmax", "ymax", "confidence", "class", "name" # xyxy columns
\n cb = "xcenter", "ycenter", "width", "height", "confidence", "class", "name" # xywh columns
\n for k, c in zip(["xyxy", "xyxyn", "xywh", "xywhn"], [ca, ca, cb, cb]):
\n a = [[x[:5] + [int(x[5]), self.names[int(x[5])]] for x in x.tolist()] for x in getattr(self, k)] # update
\n setattr(new, k, [pd.DataFrame(x, columns=c) for x in a])
\n return new<\/p>\n
\n """
\n Converts a Detections object into a list of individual detection results for iteration.<\/p>\n
\n """
\n r = range(self.n) # iterable
\n return [
\n Detections(
\n [self.ims[i]],
\n [self.pred[i]],
\n [self.files[i]],
\n self.times,
\n self.names,
\n self.s,
\n )
\n for i in r
\n ]<\/p>\n
\n """Logs the string representation of the current object's state via the LOGGER."""
\n LOGGER.info(self.__str__())<\/p>\n
\n """Returns the number of results stored, overrides the default len(results)."""
\n return self.n<\/p>\n
\n """Returns a string representation of the model's results, suitable for printing, overrides default
\n print(results).
\n """
\n return self._run(pprint=True) # print results<\/p>\n
\n """Returns a string representation of the YOLOv5 object, including its class and formatted results."""
\n return f"YOLOv5 {self.__class__} instance\\\\n" + self.__str__()<\/p>\n
\n """YOLOv5 mask Proto module for segmentation models, performing convolutions and upsampling on input tensors."""<\/p>\n
\n """Initializes YOLOv5 Proto module for segmentation with input, proto, and mask channels configuration."""
\n super().__init__()
\n self.cv1 = Conv(c1, c_, k=3)
\n self.upsample = nn.Upsample(scale_factor=2, mode="nearest")
\n self.cv2 = Conv(c_, c_, k=3)
\n self.cv3 = Conv(c_, c2)<\/p>\n
\n """Performs a forward pass using convolutional layers and upsampling on input tensor `x`."""
\n return self.cv3(self.cv2(self.upsample(self.cv1(x))))<\/p>\n
\n """YOLOv5 classification head with convolution, pooling, and dropout layers for channel transformation."""<\/p>\n
\n self, c1, c2, k=1, s=1, p=None, g=1, dropout_p=0.0
\n ): # ch_in, ch_out, kernel, stride, padding, groups, dropout probability
\n """Initializes YOLOv5 classification head with convolution, pooling, and dropout layers for input to output
\n channel transformation.
\n """
\n super().__init__()
\n c_ = 1280 # efficientnet_b0 size
\n self.conv = Conv(c1, c_, k, s, autopad(k, p), g)
\n self.pool = nn.AdaptiveAvgPool2d(1) # to x(b,c_,1,1)
\n self.drop = nn.Dropout(p=dropout_p, inplace=True)
\n self.linear = nn.Linear(c_, c2) # to x(b,c2)<\/p>\n
\n """Processes input through conv, pool, drop, and linear layers; supports list concatenation input."""
\n if isinstance(x, list):
\n x = torch.cat(x, 1)
\n return self.linear(self.drop(self.pool(self.conv(x)).flatten(1)))<\/p>\n
\nclass RepConv(nn.Module):
\n """
\n RepConv module with training and deploy modes.<\/p>\n
\n conv1 (Conv): 3×3 convolution.
\n conv2 (Conv): 1×1 convolution.
\n bn (nn.BatchNorm2d, optional): Batch normalization for identity branch.
\n act (nn.Module): Activation function.
\n default_act (nn.Module): Default activation function (SiLU).<\/p>\n
\n https:\/\/github.com\/DingXiaoH\/RepVGG\/blob\/main\/repvgg.py
\n """<\/p>\n
\n # def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True)
\n def __init__(self, c1, c2, k=3, s=1, p=1, g=1, d=1, act=True, bn=False, deploy=False):
\n """
\n Initialize RepConv module with given parameters.<\/p>\n
\n c1 (int): Number of input channels.
\n c2 (int): Number of output channels.
\n k (int): Kernel size.
\n s (int): Stride.
\n p (int): Padding.
\n g (int): Groups.
\n d (int): Dilation.
\n act (bool | nn.Module): Activation function.
\n bn (bool): Use batch normalization for identity branch.
\n deploy (bool): Deploy mode for inference.
\n """
\n super().__init__()
\n assert k == 3 and p == 1
\n self.g = g
\n self.c1 = c1
\n self.c2 = c2
\n self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()<\/p>\n
\n # def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True)
\n self.conv1 = Conv(c1, c2, k, s, p=p, g=g, act=False)
\n self.conv2 = Conv(c1, c2, 1, s, p=(p – k \/\/ 2), g=g, act=False)<\/p>\n
\n """
\n Forward pass for deploy mode.<\/p>\n
\n x (torch.Tensor): Input tensor.<\/p>\n
\n (torch.Tensor): Output tensor.
\n """
\n return self.act(self.conv(x))<\/p>\n
\n """
\n Forward pass for training mode.<\/p>\n
\n x (torch.Tensor): Input tensor.<\/p>\n
\n (torch.Tensor): Output tensor.
\n """
\n id_out = 0 if self.bn is None else self.bn(x)
\n return self.act(self.conv1(x) + self.conv2(x) + id_out)<\/p>\n
\n """
\n Calculate equivalent kernel and bias by fusing convolutions.<\/p>\n
\n (tuple): Tuple containing:
\n – Equivalent kernel (torch.Tensor)
\n – Equivalent bias (torch.Tensor)
\n """
\n kernel3x3, bias3x3 = self._fuse_bn_tensor(self.conv1)
\n kernel1x1, bias1x1 = self._fuse_bn_tensor(self.conv2)
\n kernelid, biasid = self._fuse_bn_tensor(self.bn)
\n return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid, bias3x3 + bias1x1 + biasid<\/p>\n
\n def _pad_1x1_to_3x3_tensor(kernel1x1):
\n """
\n Pad a 1×1 kernel to 3×3 size.<\/p>\n
\n kernel1x1 (torch.Tensor): 1×1 convolution kernel.<\/p>\n
\n (torch.Tensor): Padded 3×3 kernel.
\n """
\n if kernel1x1 is None:
\n return 0
\n else:
\n return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])<\/p>\n
\n """
\n Fuse batch normalization with convolution weights.<\/p>\n
\n branch (Conv | nn.BatchNorm2d | None): Branch to fuse.<\/p>\n
\n (tuple): Tuple containing:
\n – Fused kernel (torch.Tensor)
\n – Fused bias (torch.Tensor)
\n """
\n if branch is None:
\n return 0, 0
\n if isinstance(branch, Conv):
\n kernel = branch.conv.weight
\n running_mean = branch.bn.running_mean
\n running_var = branch.bn.running_var
\n gamma = branch.bn.weight
\n beta = branch.bn.bias
\n eps = branch.bn.eps
\n elif isinstance(branch, nn.BatchNorm2d):
\n if not hasattr(self, "id_tensor"):
\n input_dim = self.c1 \/\/ self.g
\n kernel_value = np.zeros((self.c1, input_dim, 3, 3), dtype=np.float32)
\n for i in range(self.c1):
\n kernel_value[i, i % input_dim, 1, 1] = 1
\n self.id_tensor = torch.from_numpy(kernel_value).to(branch.weight.device)
\n kernel = self.id_tensor
\n running_mean = branch.running_mean
\n running_var = branch.running_var
\n gamma = branch.weight
\n beta = branch.bias
\n eps = branch.eps
\n std = (running_var + eps).sqrt()
\n t = (gamma \/ std).reshape(-1, 1, 1, 1)
\n return kernel * t, beta – running_mean * gamma \/ std<\/p>\n
\n """Fuse convolutions for inference by creating a single equivalent convolution."""
\n if hasattr(self, "conv"):
\n return
\n kernel, bias = self.get_equivalent_kernel_bias()<\/p>\n
\n in_channels=self.c1,
\n out_channels=self.c2,
\n kernel_size=self.s,
\n stride=self.conv1.conv.stride,
\n padding=self.conv1.conv.padding,
\n dilation=self.conv1.conv.dilation,
\n groups=self.conv1.conv.groups,
\n bias=True,
\n ).requires_grad_(False)
\n self.conv.weight.data = kernel
\n self.conv.bias.data = bias
\n for para in self.parameters():
\n para.detach_()
\n self.__delattr__("conv1")
\n self.__delattr__("conv2")
\n if hasattr(self, "nm"):
\n self.__delattr__("nm")
\n if hasattr(self, "bn"):
\n self.__delattr__("bn")
\n if hasattr(self, "id_tensor"):
\n self.__delattr__("id_tensor")<\/p>\n
\n """Constructs a ECA module.
\n Args:
\n channel: Number of channels of the input feature map
\n k_size: Adaptive selection of kernel size
\n """<\/p>\n
\n super(ECA, self).__init__()
\n self.avg_pool = nn.AdaptiveAvgPool2d(1)
\n self.conv = nn.Conv1d(1, 1, kernel_size=k_size, padding=(k_size – 1) \/\/ 2, bias=False)
\n self.sigmoid = nn.Sigmoid()<\/p>\n
\n # feature descriptor on the global spatial information
\n y = self.avg_pool(x)
\n y = self.conv(y.squeeze(-1).transpose(-1, -2)).transpose(-1, -2).unsqueeze(-1)
\n # Multi-scale information fusion
\n y = self.sigmoid(y)<\/p>\n\u5f15\u5165\u521b\u65b0\u6a21\u5757（\u8fdb\u9636，\u53ef\u9009）<\/span><\/h4>\n
\n# \u4fee\u6539 yolo.py
\n# Ultralytics 🚀 AGPL-3.0 License – https:\/\/ultralytics.com\/license
\n"""
\nYOLO-specific modules.<\/p>\n
\n $ python models\/yolo.py –cfg yolov5s.yaml
\n"""<\/p>\n
\nimport contextlib
\nimport math
\nimport os
\nimport platform
\nimport sys
\nfrom copy import deepcopy
\nfrom pathlib import Path<\/p>\n
\nimport torch.nn as nn<\/p>\n
\nROOT = FILE.parents[1] # YOLOv5 root directory
\nif str(ROOT) not in sys.path:
\n sys.path.append(str(ROOT)) # add ROOT to PATH
\nif platform.system() != "Windows":
\n ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
\nfrom models.common import (
\n ECA,
\n C3,
\n C3SPP,
\n C3TR,
\n SPP,
\n SPPF,
\n Bottleneck,
\n BottleneckCSP,
\n C3Ghost,
\n C3x,
\n Classify,
\n Concat,
\n Contract,
\n Conv,
\n RepConv,
\n CrossConv,
\n DetectMultiBackend,
\n DWConv,
\n DWConvTranspose2d,
\n Expand,
\n Focus,
\n GhostBottleneck,
\n GhostConv,
\n Proto,
\n)
\nfrom models.experimental import MixConv2d
\nfrom utils.autoanchor import check_anchor_order
\nfrom utils.general import LOGGER, check_version, check_yaml, colorstr, make_divisible, print_args
\nfrom utils.plots import feature_visualization
\nfrom utils.torch_utils import (
\n fuse_conv_and_bn,
\n initialize_weights,
\n model_info,
\n profile,
\n scale_img,
\n select_device,
\n time_sync,
\n)<\/p>\n
\n import thop # for FLOPs computation
\nexcept ImportError:
\n thop = None<\/p>\n
\n """YOLOv5 Detect head for processing input tensors and generating detection outputs in object detection models."""<\/p>\n
\n dynamic = False # force grid reconstruction
\n export = False # export mode<\/p>\n
\n """Initializes YOLOv5 detection layer with specified classes, anchors, channels, and inplace operations."""
\n super().__init__()
\n self.nc = nc # number of classes
\n self.no = nc + 5 # number of outputs per anchor
\n self.nl = len(anchors) # number of detection layers
\n self.na = len(anchors[0]) \/\/ 2 # number of anchors
\n self.grid = [torch.empty(0) for _ in range(self.nl)] # init grid
\n self.anchor_grid = [torch.empty(0) for _ in range(self.nl)] # init anchor grid
\n self.register_buffer("anchors", torch.tensor(anchors).float().view(self.nl, -1, 2)) # shape(nl,na,2)
\n self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch) # output conv
\n self.inplace = inplace # use inplace ops (e.g. slice assignment)<\/p>\n
\n """Processes input through YOLOv5 layers, altering shape for detection: `x(bs, 3, ny, nx, 85)`."""
\n z = [] # inference output
\n for i in range(self.nl):
\n x[i] = self.m[i](x[i]) # conv
\n bs, _, ny, nx = x[i].shape # x(bs,255,20,20) to x(bs,3,20,20,85)
\n x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()<\/p>\n
\n if self.dynamic or self.grid[i].shape[2:4] != x[i].shape[2:4]:
\n self.grid[i], self.anchor_grid[i] = self._make_grid(nx, ny, i)<\/p>\n
\n xy, wh, conf, mask = x[i].split((2, 2, self.nc + 1, self.no – self.nc – 5), 4)
\n xy = (xy.sigmoid() * 2 + self.grid[i]) * self.stride[i] # xy
\n wh = (wh.sigmoid() * 2) ** 2 * self.anchor_grid[i] # wh
\n y = torch.cat((xy, wh, conf.sigmoid(), mask), 4)
\n else: # Detect (boxes only)
\n xy, wh, conf = x[i].sigmoid().split((2, 2, self.nc + 1), 4)
\n xy = (xy * 2 + self.grid[i]) * self.stride[i] # xy
\n wh = (wh * 2) ** 2 * self.anchor_grid[i] # wh
\n y = torch.cat((xy, wh, conf), 4)
\n z.append(y.view(bs, self.na * nx * ny, self.no))<\/p>\n
\n """Generates a mesh grid for anchor boxes with optional compatibility for torch versions < 1.10."""
\n d = self.anchors[i].device
\n t = self.anchors[i].dtype
\n shape = 1, self.na, ny, nx, 2 # grid shape
\n y, x = torch.arange(ny, device=d, dtype=t), torch.arange(nx, device=d, dtype=t)
\n yv, xv = torch.meshgrid(y, x, indexing="ij") if torch_1_10 else torch.meshgrid(y, x) # torch>=0.7 compatibility
\n grid = torch.stack((xv, yv), 2).expand(shape) – 0.5 # add grid offset, i.e. y = 2.0 * x – 0.5
\n anchor_grid = (self.anchors[i] * self.stride[i]).view((1, self.na, 1, 1, 2)).expand(shape)
\n return grid, anchor_grid<\/p>\n
\n """YOLOv5 Segment head for segmentation models, extending Detect with mask and prototype layers."""<\/p>\n
\n """Initializes YOLOv5 Segment head with options for mask count, protos, and channel adjustments."""
\n super().__init__(nc, anchors, ch, inplace)
\n self.nm = nm # number of masks
\n self.npr = npr # number of protos
\n self.no = 5 + nc + self.nm # number of outputs per anchor
\n self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch) # output conv
\n self.proto = Proto(ch[0], self.npr, self.nm) # protos
\n self.detect = Detect.forward<\/p>\n
\n """Processes input through the network, returning detections and prototypes; adjusts output based on
\n training\/export mode.
\n """
\n p = self.proto(x[0])
\n x = self.detect(self, x)
\n return (x, p) if self.training else (x[0], p) if self.export else (x[0], p, x[1])<\/p>\n
\n """YOLOv5 base model."""<\/p>\n
\n """Executes a single-scale inference or training pass on the YOLOv5 base model, with options for profiling and
\n visualization.
\n """
\n return self._forward_once(x, profile, visualize) # single-scale inference, train<\/p>\n
\n """Performs a forward pass on the YOLOv5 model, enabling profiling and feature visualization options."""
\n y, dt = [], [] # outputs
\n for m in self.model:
\n if m.f != -1: # if not from previous layer
\n 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
\n if profile:
\n self._profile_one_layer(m, x, dt)
\n x = m(x) # run
\n y.append(x if m.i in self.save else None) # save output
\n if visualize:
\n feature_visualization(x, m.type, m.i, save_dir=visualize)
\n return x<\/p>\n
\n """Profiles a single layer's performance by computing GFLOPs, execution time, and parameters."""
\n c = m == self.model[-1] # is final layer, copy input as inplace fix
\n o = thop.profile(m, inputs=(x.copy() if c else x,), verbose=False)[0] \/ 1e9 * 2 if thop else 0 # FLOPs
\n t = time_sync()
\n for _ in range(10):
\n m(x.copy() if c else x)
\n dt.append((time_sync() – t) * 100)
\n if m == self.model[0]:
\n LOGGER.info(f"{'time (ms)':>10s} {'GFLOPs':>10s} {'params':>10s} module")
\n LOGGER.info(f"{dt[-1]:10.2f} {o:10.2f} {m.np:10.0f} {m.type}")
\n if c:
\n LOGGER.info(f"{sum(dt):10.2f} {'-':>10s} {'-':>10s} Total")<\/p>\n
\n """Fuses Conv2d() and BatchNorm2d() layers in the model to improve inference speed."""
\n LOGGER.info("Fusing layers… ")
\n for m in self.model.modules():
\n if isinstance(m, (Conv, DWConv)) and hasattr(m, "bn"):
\n m.conv = fuse_conv_and_bn(m.conv, m.bn) # update conv
\n delattr(m, "bn") # remove batchnorm
\n m.forward = m.forward_fuse # update forward
\n self.info()
\n return self<\/p>\n
\n """Prints model information given verbosity and image size, e.g., `info(verbose=True, img_size=640)`."""
\n model_info(self, verbose, img_size)<\/p>\n
\n """Applies transformations like to(), cpu(), cuda(), half() to model tensors excluding parameters or registered
\n buffers.
\n """
\n self = super()._apply(fn)
\n m = self.model[-1] # Detect()
\n if isinstance(m, (Detect, Segment)):
\n m.stride = fn(m.stride)
\n m.grid = list(map(fn, m.grid))
\n if isinstance(m.anchor_grid, list):
\n m.anchor_grid = list(map(fn, m.anchor_grid))
\n return self<\/p>\n
\n """YOLOv5 detection model class for object detection tasks, supporting custom configurations and anchors."""<\/p>\n
\n """Initializes YOLOv5 model with configuration file, input channels, number of classes, and custom anchors."""
\n super().__init__()
\n if isinstance(cfg, dict):
\n self.yaml = cfg # model dict
\n else: # is *.yaml
\n import yaml # for torch hub<\/p>\n
\n with open(cfg, encoding="ascii", errors="ignore") as f:
\n self.yaml = yaml.safe_load(f) # model dict<\/p>\n
\n ch = self.yaml["ch"] = self.yaml.get("ch", ch) # input channels
\n if nc and nc != self.yaml["nc"]:
\n LOGGER.info(f"Overriding model.yaml nc={self.yaml['nc']} with nc={nc}")
\n self.yaml["nc"] = nc # override yaml value
\n if anchors:
\n LOGGER.info(f"Overriding model.yaml anchors with anchors={anchors}")
\n self.yaml["anchors"] = round(anchors) # override yaml value
\n self.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch]) # model, savelist
\n self.names = [str(i) for i in range(self.yaml["nc"])] # default names
\n self.inplace = self.yaml.get("inplace", True)<\/p>\n
\n m = self.model[-1] # Detect()
\n if isinstance(m, (Detect, Segment)):<\/p>\n
\n """Passes the input 'x' through the model and returns the processed output."""
\n return self.forward(x)[0] if isinstance(m, Segment) else self.forward(x)<\/p>\n
\n m.inplace = self.inplace
\n m.stride = torch.tensor([s \/ x.shape[-2] for x in _forward(torch.zeros(1, ch, s, s))]) # forward
\n check_anchor_order(m)
\n m.anchors \/= m.stride.view(-1, 1, 1)
\n self.stride = m.stride
\n self._initialize_biases() # only run once<\/p>\n
\n initialize_weights(self)
\n self.info()
\n LOGGER.info("")<\/p>\n
\n """Performs single-scale or augmented inference and may include profiling or visualization."""
\n if augment:
\n return self._forward_augment(x) # augmented inference, None
\n return self._forward_once(x, profile, visualize) # single-scale inference, train<\/p>\n
\n """Performs augmented inference across different scales and flips, returning combined detections."""
\n img_size = x.shape[-2:] # height, width
\n s = [1, 0.83, 0.67] # scales
\n f = [None, 3, None] # flips (2-ud, 3-lr)
\n y = [] # outputs
\n for si, fi in zip(s, f):
\n xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max()))
\n yi = self._forward_once(xi)[0] # forward
\n # cv2.imwrite(f'img_{si}.jpg', 255 * xi[0].cpu().numpy().transpose((1, 2, 0))[:, :, ::-1]) # save
\n yi = self._descale_pred(yi, fi, si, img_size)
\n y.append(yi)
\n y = self._clip_augmented(y) # clip augmented tails
\n return torch.cat(y, 1), None # augmented inference, train<\/p>\n
\n """De-scales predictions from augmented inference, adjusting for flips and image size."""
\n if self.inplace:
\n p[…, :4] \/= scale # de-scale
\n if flips == 2:
\n p[…, 1] = img_size[0] – p[…, 1] # de-flip ud
\n elif flips == 3:
\n p[…, 0] = img_size[1] – p[…, 0] # de-flip lr
\n else:
\n x, y, wh = p[…, 0:1] \/ scale, p[…, 1:2] \/ scale, p[…, 2:4] \/ scale # de-scale
\n if flips == 2:
\n y = img_size[0] – y # de-flip ud
\n elif flips == 3:
\n x = img_size[1] – x # de-flip lr
\n p = torch.cat((x, y, wh, p[…, 4:]), -1)
\n return p<\/p>\n
\n """Clips augmented inference tails for YOLOv5 models, affecting first and last tensors based on grid points and
\n layer counts.
\n """
\n nl = self.model[-1].nl # number of detection layers (P3-P5)
\n g = sum(4**x for x in range(nl)) # grid points
\n e = 1 # exclude layer count
\n i = (y[0].shape[1] \/\/ g) * sum(4**x for x in range(e)) # indices
\n y[0] = y[0][:, :-i] # large
\n i = (y[-1].shape[1] \/\/ g) * sum(4 ** (nl – 1 – x) for x in range(e)) # indices
\n y[-1] = y[-1][:, i:] # small
\n return y<\/p>\n
\n """
\n Initializes biases for YOLOv5's Detect() module, optionally using class frequencies (cf).<\/p>\n
\n """
\n # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.
\n m = self.model[-1] # Detect() module
\n for mi, s in zip(m.m, m.stride): # from
\n b = mi.bias.view(m.na, -1) # conv.bias(255) to (3,85)
\n b.data[:, 4] += math.log(8 \/ (640 \/ s) ** 2) # obj (8 objects per 640 image)
\n b.data[:, 5 : 5 + m.nc] += (
\n math.log(0.6 \/ (m.nc – 0.99999)) if cf is None else torch.log(cf \/ cf.sum())
\n ) # cls
\n mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)<\/p>\n
\n """YOLOv5 segmentation model for object detection and segmentation tasks with configurable parameters."""<\/p>\n
\n """Initializes a YOLOv5 segmentation model with configurable params: cfg (str) for configuration, ch (int) for channels, nc (int) for num classes, anchors (list)."""
\n super().__init__(cfg, ch, nc, anchors)<\/p>\n
\n """YOLOv5 classification model for image classification tasks, initialized with a config file or detection model."""<\/p>\n
\n """Initializes YOLOv5 model with config file `cfg`, input channels `ch`, number of classes `nc`, and `cuttoff`
\n index.
\n """
\n super().__init__()
\n self._from_detection_model(model, nc, cutoff) if model is not None else self._from_yaml(cfg)<\/p>\n
\n """Creates a classification model from a YOLOv5 detection model, slicing at `cutoff` and adding a classification
\n layer.
\n """
\n if isinstance(model, DetectMultiBackend):
\n model = model.model # unwrap DetectMultiBackend
\n model.model = model.model[:cutoff] # backbone
\n m = model.model[-1] # last layer
\n ch = m.conv.in_channels if hasattr(m, "conv") else m.cv1.conv.in_channels # ch into module
\n c = Classify(ch, nc) # Classify()
\n c.i, c.f, c.type = m.i, m.f, "models.common.Classify" # index, from, type
\n model.model[-1] = c # replace
\n self.model = model.model
\n self.stride = model.stride
\n self.save = []
\n self.nc = nc<\/p>\n
\n """Creates a YOLOv5 classification model from a specified *.yaml configuration file."""
\n self.model = None<\/p>\n
\ndef parse_model(d, ch):
\n """Parses a YOLOv5 model from a dict `d`, configuring layers based on input channels `ch` and model architecture."""
\n LOGGER.info(f"\\\\n{'':>3}{'from':>18}{'n':>3}{'params':>10} {'module':<40}{'arguments':<30}")
\n anchors, nc, gd, gw, act, ch_mul = (
\n d["anchors"],
\n d["nc"],
\n d["depth_multiple"],
\n d["width_multiple"],
\n d.get("activation"),
\n d.get("channel_multiple"),
\n )
\n # \u5982\u679c act \u914d\u7f6e\u9879\u5b58\u5728，\u5c31\u6839\u636e\u914d\u7f6e\u4fee\u6539\u5377\u79ef\u5c42\u7684\u9ed8\u8ba4\u6fc0\u6d3b\u51fd\u6570\u3002
\n if act:
\n Conv.default_act = eval(act) # redefine default activation, i.e. Conv.default_act = nn.SiLU()
\n RepConv.default_act = eval(act)<\/p>\n
\n if not ch_mul:
\n ch_mul = 8
\n # \u6bcf\u4e2a\u951a\u70b9\u7684\u6570\u91cf，\u901a\u5e38\u4e3a\u951a\u70b9\u5217\u8868\u4e2d\u7684\u6bcf\u5bf9(width, height)
\n na = (len(anchors[0]) \/\/ 2) if isinstance(anchors, list) else anchors # number of anchors
\n # \u6bcf\u4e2a\u8f93\u51fa\u7684\u901a\u9053\u6570，\u8ba1\u7b97\u516c\u5f0f\u4e3a \u951a\u70b9\u6570 * (\u7c7b\u522b\u6570 + 5)，5 \u4ee3\u8868\u8fb9\u754c\u6846\u7684 4 \u4e2a\u5750\u6807\u52a0\u4e0a\u7f6e\u4fe1\u5ea6\u3002
\n no = na * (nc + 5) # number of outputs = anchors * (classes + 5)<\/p>\n
\n # \u89e3\u6790\u6bcf\u4e00\u884c\u7ed3\u6784
\n for i, (f, n, m, args) in enumerate(d["backbone"] + d["head"]): # from, number, module, args
\n # \u52a8\u6001\u89e3\u6790\u5b57\u7b26\u4e32\u4e3a\u5bf9\u5e94\u7684\u7c7b
\n m = eval(m) if isinstance(m, str) else m # eval strings
\n for j, a in enumerate(args):
\n with contextlib.suppress(NameError):
\n args[j] = eval(a) if isinstance(a, str) else a # eval strings
\n # \u91cd\u590d\u6570\u91cf
\n n = n_ = max(round(n * gd), 1) if n > 1 else n # depth gain
\n # \u5377\u79ef\u5c42\u5904\u7406
\n if m in {
\n Conv,
\n RepConv,
\n GhostConv,
\n Bottleneck,
\n GhostBottleneck,
\n SPP,
\n SPPF,
\n DWConv,
\n MixConv2d,
\n Focus,
\n CrossConv,
\n BottleneckCSP,
\n C3,
\n ECA,
\n C3TR,
\n C3SPP,
\n C3Ghost,
\n nn.ConvTranspose2d,
\n DWConvTranspose2d,
\n C3x,
\n }:
\n c1, c2 = ch[f], args[0]
\n if c2 != no: # if not output
\n c2 = make_divisible(c2 * gw, ch_mul)<\/p>\n
\n if m in {BottleneckCSP, C3, C3TR, C3Ghost, C3x}:
\n args.insert(2, n) # number of repeats
\n n = 1
\n elif m is nn.BatchNorm2d:
\n args = [ch[f]]
\n elif m is Concat:
\n c2 = sum(ch[x] for x in f)
\n # TODO: channel, gw, gd
\n elif m in {Detect, Segment}:
\n args.append([ch[x] for x in f])
\n if isinstance(args[1], int): # number of anchors
\n args[1] = [list(range(args[1] * 2))] * len(f)
\n if m is Segment:
\n args[3] = make_divisible(args[3] * gw, ch_mul)
\n elif m is Contract:
\n c2 = ch[f] * args[0] ** 2
\n elif m is Expand:
\n c2 = ch[f] \/\/ args[0] ** 2
\n else:
\n c2 = ch[f]<\/p>\n
\n t = str(m)[8:-2].replace("__main__.", "") # module type
\n np = sum(x.numel() for x in m_.parameters()) # number params
\n m_.i, m_.f, m_.type, m_.np = i, f, t, np # attach index, 'from' index, type, number params
\n LOGGER.info(f"{i:>3}{str(f):>18}{n_:>3}{np:10.0f} {t:<40}{str(args):<30}") # print
\n save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1) # append to savelist
\n # \u4fdd\u5b58\u7ed3\u6784\u5c42
\n layers.append(m_)
\n if i == 0:
\n ch = []
\n ch.append(c2)
\n return nn.Sequential(*layers), sorted(save)<\/p>\n
\n parser = argparse.ArgumentParser()
\n parser.add_argument("–cfg", type=str, default="yolov5s_custom.yaml", help="model.yaml")
\n parser.add_argument("–batch-size", type=int, default=1, help="total batch size for all GPUs")
\n parser.add_argument("–device", default="cpu", help="cuda device, i.e. 0 or 0,1,2,3 or cpu")
\n parser.add_argument("–profile", action="store_true", help="profile model speed")
\n parser.add_argument("–line-profile", action="store_true", help="profile model speed layer by layer")
\n parser.add_argument("–test", action="store_true", help="test all yolo*.yaml")
\n opt = parser.parse_args()
\n opt.cfg = check_yaml(opt.cfg) # check YAML
\n print_args(vars(opt))
\n device = select_device(opt.device)<\/p>\n
\n im = torch.rand(opt.batch_size, 3, 640, 640).to(device)
\n model = Model(opt.cfg).to(device)<\/p>\n
\n if opt.line_profile: # profile layer by layer
\n model(im, profile=True)<\/p>\n
\n results = profile(input=im, ops=[model], n=3)<\/p>\n
\n for cfg in Path(ROOT \/ "models").rglob("yolo*.yaml"):
\n try:
\n _ = Model(cfg)
\n except Exception as e:
\n print(f"Error in {cfg}: {e}")<\/p>\n
\n model.fuse()<\/p>\n<\/h2>\n
\u8bad\u7ec3\u6a21\u578b<\/span><\/h2>\n
\n
\n\u00a0import zipfile
\n\u00a0\u200b
\n\u00a0def zip_folder(source_folder, output_zip):
\n\u00a0 \u00a0 """
\n\u00a0 \u00a0 \u5c06\u6307\u5b9a\u76ee\u5f55\u6253\u5305\u4e3a ZIP \u6587\u4ef6\u3002
\n\u00a0 \u00a0 \u00a0
\n\u00a0 \u00a0 :param source_folder: \u9700\u8981\u538b\u7f29\u7684\u76ee\u5f55\u8def\u5f84
\n\u00a0 \u00a0 :param output_zip: \u8f93\u51fa ZIP \u6587\u4ef6\u7684\u5b8c\u6574\u8def\u5f84（\u5305\u542b .zip）
\n\u00a0 \u00a0 """
\n\u00a0 \u00a0 with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:
\n\u00a0 \u00a0 \u00a0 \u00a0 for root, dirs, files in os.walk(source_folder):
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 for file in files:
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 file_path = os.path.join(root, file)
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 arcname = os.path.relpath(file_path, source_folder) # \u4fdd\u6301\u76f8\u5bf9\u8def\u5f84
\n\u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 zipf.write(file_path, arcname)
\n\u00a0 \u00a0 print(f"\u6587\u4ef6\u5939 '{source_folder}' \u5df2\u6210\u529f\u538b\u7f29\u81f3 '{output_zip}'")
\n\u00a0\u200b
\n\u00a0if __name__ == "__main__":
\n\u00a0 \u00a0 source_directory = ".\/runs\/train\/exp2" # \u9700\u8981\u538b\u7f29\u7684\u6587\u4ef6\u5939\u8def\u5f84
\n\u00a0 \u00a0 output_zip_path = ".\/ECA_4_9_150.zip" # \u76ee\u6807 ZIP \u6587\u4ef6\u8def\u5f84
\n\u00a0 \u00a0 \u00a0
\n\u00a0 \u00a0 # \u786e\u4fdd\u8f93\u51fa\u76ee\u5f55\u5b58\u5728
\n\u00a0 \u00a0 os.makedirs(os.path.dirname(output_zip_path), exist_ok=True)
\n\u00a0 \u00a0 \u00a0
\n\u00a0 \u00a0 zip_folder(source_directory, output_zip_path)
\n\u00a0# \u7ec8\u6b62\u8bad\u7ec3
\n\u00a0# !pkill -9 -f train.py <\/p>\n\u6587\u7ae0\u603b\u7ed3<\/span><\/h2>\n
\n
\n\u5176\u4ed6\u7cbe\u5f69\u5185\u5bb9：<\/span><\/h5>\n<\/p>\n
\n\u53c2\u8003\u5185\u5bb9：<\/span><\/h5>\n","protected":false},"excerpt":{"rendered":"