企业官网建设流程全解析

简介：本资源是一份面向深度学习初学者与目标检测实践者的YOLOv8网络结构解析教程，聚焦模型架构原理与可视化绘制方法，解决读者对Backbone、Neck、Head三大模块及C2f、SPPF、Upsample、Concat、Detect等核心组件理解不深、难以手绘或复现结构图的痛点。文档以Word（.doc）格式呈现，共1个文件，体积精简仅53KB，内容涵盖整体架构概述、6大模块逐层详解、Visio/Graphviz/Mermaid绘图实操步骤、配置文件（yolov8.yaml）与PyTorch代码对应关系解析、Netron可视化工具使用说明，以及与YOLOv5的结构对比和轻量化改进思路。目前已有2307人学习下载，适合希望深入掌握YOLOv8底层设计、开展模型定制优化或完成课程作业与技术报告的学习者。

1. YOLOv8 网络结构图的详细教程：不是画个框图就叫“看懂了”，而是能对着图反推 forward 流程、定位 bottleneck、改 head 不翻车

你有没有试过打开 Ultralytics 官方 GitHub 仓库，点开ultralytics/nn/modules.py，满屏的Conv,C2f,SPPF,Detect类，再切到ultralytics/nn/tasks.py里那个嵌套三层的DetectionModel._from_yaml()，越看越像黑匣子？或者用 Netron 打开一个.pt模型，只看到一堆带 shape 的节点，却说不清哪个C2f对应 backbone 第 3 个 stage、哪个Detect的cv2分支负责 class score——这根本不是“看懂结构图”，只是在看拓扑快照。这篇教程要解决的，是把 YOLOv8 的网络结构图从静态示意图，变成可执行、可调试、可修改的动态认知地图。它不教你怎么用yolo train跑通，而是带你亲手从源码里“长”出结构图：用torch.jit.trace抽出计算图、用graphviz渲染带模块名和 shape 的 SVG、用model.named_modules()逐层校验 tensor 流动路径。适合正在做模型轻量化（比如部署到 RK3588）、想自定义检测头（如加 CSL、换 Anchor-Free）、或被RuntimeError: Expected all tensors to be on the same device卡住半天却找不到哪层漏了.to(device)的一线算法工程师和进阶使用者。小白慎入——这里没有一键绘图脚本，只有你亲手拆解、验证、踩坑后长出来的肌肉记忆。

2. 从源码出发：三步生成带 shape 和模块名的 YOLOv8 结构图（非 Netron 快照）

YOLOv8 的结构图不能靠截图或手绘，必须从运行时模型中“活体提取”。Ultralytics 官方不提供预渲染的高清结构图（不像 YOLOv5 有models/yolov5s.yaml配合models/common.py可直观对应），它的模块高度封装、动态构建，直接读yaml文件会漏掉C2f内部的Bottleneck堆叠逻辑、Detect中cv2和cv3的 channel 分配细节。所以，我们绕过配置文件，直击 PyTorch 计算图本身。核心思路是：用 trace 固化前向路径 → 用 TorchScript Graph 提取节点属性 → 用 graphviz 渲染为可读 SVG。这个过程生成的图，每个节点都带真实 shape、模块类名、输入输出 tensor 维度，且与你实际训练/推理时的模型完全一致。

2.1 准备最小可运行模型并 trace 出计算图

先确保环境干净：Ultralytics ≥ 8.0.200（低版本C2f实现不同，trace 会失败），PyTorch ≥ 2.0.1（需支持torch.jit.trace对nn.Sequential的完整捕获）：

pip install ultralytics torch torchvision --upgrade

然后创建gen_graph.py，关键不是加载预训练权重，而是构造一个无权重、仅结构的模型实例，并用 dummy input trace：

# gen_graph.py import torch from ultralytics import YOLO from torch import nn # 1. 创建最小模型：不加载权重，避免显存占用和初始化干扰 model = YOLO('yolov8n.yaml') # 注意：这里是 yaml 配置，不是 .pt 权重！ model.model.eval() # 切换到 eval 模式，禁用 dropout/bn 训练态 # 2. 构造 dummy input：必须匹配模型期望的输入 shape # YOLOv8 默认输入是 [B, C, H, W]，H/W 必须是 32 的倍数（因下采样总 stride=32） dummy_input = torch.randn(1, 3, 640, 640) # B=1, C=3, H=640, W=640 # 3. trace：注意要 trace model.model，不是整个 YOLO 对象 # 因为 YOLO 封装了 pre/post-processing，我们只要纯 backbone+neck+head traced_model = torch.jit.trace(model.model, dummy_input) # 4. 保存为 .pt 文件，供后续 graphviz 解析 traced_model.save("yolov8n_traced.pt") print("✅ Trace completed. Saved to yolov8n_traced.pt")

逻辑说明：model.model是DetectionModel实例，即纯神经网络；torch.jit.trace在首次前向时记录所有操作，生成静态计算图。用yolov8n.yaml而非yolov8n.pt，是为了排除权重初始化对图结构的影响——我们要的是“结构骨架”，不是“带肉的躯体”。dummy_input的640x640是 YOLOv8 默认尺寸，若你用yolov8s.yaml，shape 保持一致即可，结构图不会变。

2.2 解析 TorchScript Graph 并提取节点信息

TorchScript Graph 是底层 IR，节点名抽象（如aten::add），但我们可以用torch._C.GraphAPI 提取模块名和 shape。新建parse_graph.py：

# parse_graph.py import torch import re def extract_node_info(graph): """从 TorchScript Graph 中提取关键节点信息：name, op, input_shape, output_shape""" nodes = [] # 遍历所有节点（包括 prim::GetAttr 获取模块属性） for node in graph.nodes(): # 过滤掉控制流和属性获取节点，聚焦计算节点 if node.kind() in ['prim::GetAttr', 'prim::Constant']: continue # 获取节点输入输出的 type（含 shape） inputs = list(node.inputs()) outputs = list(node.outputs()) # 尝试从输入中解析 shape（TorchScript 中 shape 存在 Type 中） input_shape = "unknown" output_shape = "unknown" if inputs and hasattr(inputs[0].type(), 'sizes'): try: input_shape = str(inputs[0].type().sizes()) except: pass if outputs and hasattr(outputs[0].type(), 'sizes'): try: output_shape = str(outputs[0].type().sizes()) except: pass # 获取节点操作名（如 aten::conv2d, aten::add） op = node.kind() # 尝试从节点属性中恢复模块名（关键！） module_name = "unknown" if node.hasAttribute("name"): module_name = node.s("name") elif node.hasAttribute("module_name"): module_name = node.s("module_name") nodes.append({ "name": node.scopeName() if node.scopeName() else "unnamed", "op": op, "module_name": module_name, "input_shape": input_shape, "output_shape": output_shape }) return nodes # 加载 traced 模型 traced = torch.jit.load("yolov8n_traced.pt") graph = traced.graph # 提取并打印前 20 个节点（用于调试） nodes = extract_node_info(graph) for i, n in enumerate(nodes[:20]): print(f"[{i}] {n['name']} | {n['module_name']} | {n['op']} | in:{n['input_shape']} -> out:{n['output_shape']}")

参数说明：node.scopeName()返回模块层级路径（如model.model.backbone.stem.conv），这是定位C2f或SPPF在 backbone 中位置的关键；node.kind()是底层算子（aten::conv2d），用于识别卷积层；inputs[0].type().sizes()是真实运行时 shape，比yaml里写的c1=64更可靠——因为C2f的输出 channel 由c1和c2共同决定，而c2在Detect头中才确定。这段代码不渲染图，但输出是后续画图的数据基础。

2.3 用 graphviz 渲染为带模块名和 shape 的 SVG 图

有了节点数据，用graphviz渲染成可读图。安装依赖：

pip install graphviz # 并确保系统已安装 graphviz 二进制（Ubuntu: sudo apt-get install graphviz）

创建render_graph.py：

# render_graph.py from graphviz import Digraph import torch def render_torchscript_graph_to_svg(traced_model_path, output_path="yolov8n_structure.svg"): traced = torch.jit.load(traced_model_path) graph = traced.graph dot = Digraph(comment='YOLOv8 Structure', format='svg') dot.attr(rankdir='TB', size='12,12', fontsize='10') # Top-to-Bottom, A4 大小 # 添加输入节点 dot.node('input', label='Input\n[1,3,640,640]', shape='box', style='filled', fillcolor='lightblue') # 遍历图节点，构建 graphviz 节点和边 node_id_map = {} edge_count = 0 for i, node in enumerate(graph.nodes()): if node.kind() in ['prim::GetAttr', 'prim::Constant']: continue # 生成唯一 ID node_id = f"node_{i}" node_id_map[node] = node_id # 构建 label：模块名 + op + shape module_name = "unknown" if node.hasAttribute("name"): module_name = node.s("name") elif node.scopeName(): module_name = node.scopeName().split('.')[-1] # 取最后一级名，如 'c2f_1' op = node.kind() label = f"{module_name}\n{op}" # 尝试加 shape（简化版，只取第一个 input/output） try: inp = list(node.inputs())[0] if hasattr(inp.type(), 'sizes'): label += f"\n{inp.type().sizes()}" except: pass dot.node(node_id, label=label, shape='box', style='rounded,filled', fillcolor='white') # 添加边：当前节点 -> 下一节点（简化为线性连接，实际图更复杂） for next_node in graph.nodes(): if any(inp.node() == node for inp in next_node.inputs()): dot.edge(node_id, f"node_{list(graph.nodes()).index(next_node)}", label="", fontsize='8') # 连接 input 到第一个节点 first_node = None for node in graph.nodes(): if node.kind() != 'prim::GetAttr': first_node = node break if first_node and first_node in node_id_map: dot.edge('input', node_id_map[first_node]) dot.render(output_path, view=False, cleanup=True) print(f"✅ SVG rendered to {output_path}") if __name__ == "__main__": render_torchscript_graph_to_svg("yolov8n_traced.pt")

运行后生成yolov8n_structure.svg，用浏览器打开，你会看到一个从上到下、带模块名、带部分 shape、带箭头流向的结构图。虽然不如手绘图美观，但它 100% 反映你当前模型的真实计算路径——这才是工程落地需要的“结构图”。

3. 手动绘制精简版结构图：用 Mermaid 语法描述 backbone-neck-head 三大块

自动图适合调试，但交流、文档、论文配图需要语义清晰、层次分明、重点突出的手绘风格图。Mermaid 是最佳选择：纯文本、版本可控、可嵌入 Markdown、无需安装 GUI 工具。我们不画所有Bottleneck，而是按 YOLOv8 官方设计哲学，分三层描述：Backbone（CSPDarknet53 变体）、Neck（PAN-FPN）、Head（Decoupled Head）。这张图的目标是：让你一眼看出C2f堆叠次数、SPPF插入位置、Detect中cv2/cv3的 channel 数量来源。

3.1 Backbone：CSPDarknet53 的 YOLOv8 改进版（C2f 替代 C3）

YOLOv8 的 backbone 不是简单复刻 YOLOv5 的 CSPDarknet53，而是用C2f（Cross Stage Partial networks with 2 convolutions + fusing）替代了C3。C2f的核心是：保留更多梯度流、减少参数量、提升小目标特征融合能力。其结构是：输入 split 为两路 → 主干路经多个Bottleneck→ 两路 concat → 1x1 conv 调整 channel。在yolov8n.yaml中，backbone 定义为：

backbone: # [from, repeats, module, args] - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2 - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4 - [-1, 3, C2f, [128, True]] # 2-P2/4 - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8 - [-1, 6, C2f, [256, True]] # 4-P3/8 - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16 - [-1, 6, C2f, [512, True]] # 6-P4/16 - [-1, 1, Conv, [1024, 3, 2]]# 7-P5/32 - [-1, 3, C2f, [1024, True]] # 8-P5/32 - [-1, 1, SPPF, [1024, 5]] # 9-P5/32

对应 Mermaid 图（复制到支持 Mermaid 的编辑器如 Typora、VSCode 插件中即可渲染）：

flowchart TD A[Input<br>[1,3,640,640]] --> B[Conv64<br>3x3 s=2] B --> C[Conv128<br>3x3 s=2] C --> D[C2f-128<br>3×Bottleneck] D --> E[Conv256<br>3x3 s=2] E --> F[C2f-256<br>6×Bottleneck] F --> G[Conv512<br>3x3 s=2] G --> H[C2f-512<br>6×Bottleneck] H --> I[Conv1024<br>3x3 s=2] I --> J[C2f-1024<br>3×Bottleneck] J --> K[SPPF-1024<br>5x5 maxpool] K --> L[Backbone Output<br>P5/32<br>[1,1024,20,20]] style A fill:#4CAF50,stroke:#388E3C,color:white style L fill:#2196F3,stroke:#0D47A1,color:white

关键参数说明：C2f-128表示该模块输入/输出 channel 为 128，内部Bottleneck数量由repeats=3决定；SPPF的5指最大池化核大小（5x5），它接收C2f-1024输出，输出仍是[1,1024,20,20]（H/W 不变）。这张图省略了C2f内部的 split-fuse 细节，但标出了每层的输出分辨率（P2/P3/P4/P5）和 channel，这是部署到 RK3588 时计算内存带宽的关键依据。

3.2 Neck：PAN-FPN 的双向特征金字塔（上采样 + 下采样融合）

YOLOv8 的 neck 是 PAN-FPN（Path Aggregation Network + Feature Pyramid Network）的紧凑实现，特点是：自顶向下（top-down）传递语义信息，自底向上（bottom-up）增强定位细节。yolov8n.yaml中定义为：

neck: - [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 10 - [[-1, 6], 1, Concat, [1]] # 11-P4/16 - [-1, 3, C2f, [512]] # 12-P4/16 - [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 13 - [[-1, 4], 1, Concat, [1]] # 14-P3/8 - [-1, 3, C2f, [256]] # 15-P3/8 - [-1, 1, Conv, [256, 3, 2]] # 16-P3/8 → P4/16 - [[-1, 12], 1, Concat, [1]] # 17-P4/16 - [-1, 3, C2f, [512]] # 18-P4/16 - [-1, 1, Conv, [512, 3, 2]] # 19-P4/16 → P5/32 - [[-1, 9], 1, Concat, [1]] # 20-P5/32 - [-1, 3, C2f, [1024]] # 21-P5/32

Mermaid 图突出“双向”和“concat 位置”：

flowchart LR subgraph TopDown P5[Backbone P5<br>[1,1024,20,20]] --> U1[UpSample x2<br>nearest] U1 --> C1[Concat w/ P4<br>[1,1024,40,40]] C1 --> C2f1[C2f-512<br>P4/16] C2f1 --> U2[UpSample x2<br>nearest] U2 --> C2[Concat w/ P3<br>[1,512,80,80]] C2 --> C2f2[C2f-256<br>P3/8] end subgraph BottomUp C2f2 --> D1[Conv256<br>3x3 s=2] D1 --> C3[Concat w/ C2f1<br>[1,1024,40,40]] C3 --> C2f3[C2f-512<br>P4/16] C2f3 --> D2[Conv512<br>3x3 s=2] D2 --> C4[Concat w/ P5<br>[1,2048,20,20]] C4 --> C2f4[C2f-1024<br>P5/32] end style P5 fill:#2196F3,stroke:#0D47A1,color:white style C2f2 fill:#FF9800,stroke:#E65100,color:white style C2f4 fill:#9C27B0,stroke:#4A148C,color:white

为什么这样设计？P3（高分辨率）负责小目标检测，但语义弱；P5（低分辨率）语义强但定位差。PAN-FPN 让 P3 获得 P4/P5 的语义，让 P5 获得 P4/P3 的细节，最终三个输出层（P3/P4/P5）各司其职。Concat的维度必须对齐：U1后P5变为[1,1024,40,40]，与P4的[1,512,40,40]concat 后是[1,1536,40,40]，再经C2f-512降维到[1,512,40,40]——这就是C2f的 channel 参数512的由来，不是拍脑袋定的。

3.3 Head：解耦检测头（Decoupled Head）与输出通道计算

YOLOv8 的 head 是彻底解耦的：cv2分支预测 class score，cv3分支预测 bbox regression（xywh）和 objectness。yolov8n.yaml中：

head: - [-1, 1, nn.Upsample, [None, 2, 'nearest']] # 22-P5/32 → P4/16 - [[-1, 15], 1, Concat, [1]] # 23-P4/16 - [-1, 3, C2f, [256]] # 24-P4/16 - [-1, 1, Conv, [256, 3, 2]] # 25-P4/16 → P5/32 - [[-1, 18], 1, Concat, [1]] # 26-P5/32 - [-1, 3, C2f, [512]] # 27-P5/32 - [-1, 1, Conv, [512, 3, 2]] # 28-P5/32 → P6/64 - [[-1, 21], 1, Concat, [1]] # 29-P6/64 - [-1, 3, C2f, [1024]] # 30-P6/64 - [[15, 18, 21], 1, Detect, [nc]] # 31-Detect

Detect模块的nc是类别数，但cv2/cv3的 channel 数由nc和 anchor 数隐式决定。Detect源码中：

# ultralytics/nn/modules.py line ~1000 self.cv2 = nn.Sequential(Conv(c_, c_, 3), Conv(c_, c_, 3), nn.Conv2d(c_, 4 * self.reg_max, 1)) # xywh, 4*reg_max self.cv3 = nn.Sequential(Conv(c_, c_, 3), Conv(c_, c_, 3), nn.Conv2d(c_, self.nc, 1)) # classes

其中c_是输入 channel（P3/P4/P5 分别为 256/512/1024），reg_max=16（DFL 参数），所以cv2输出 channel =4*16=64，cv3输出 channel =nc。最终每个尺度输出 shape 为：

• P3:[1, 256, 80, 80]→cv2:[1, 64, 80, 80],cv3:[1, nc, 80, 80]
• P4:[1, 512, 40, 40]→cv2:[1, 64, 40, 40],cv3:[1, nc, 40, 40]
• P5:[1, 1024, 20, 20]→cv2:[1, 64, 20, 20],cv3:[1, nc, 20, 20]

Mermaid 图聚焦 head 输入和输出：

flowchart LR P3[P3/8<br>[1,256,80,80]] --> Detect3[Detect P3<br>cv2:64<br>cv3:nc] P4[P4/16<br>[1,512,40,40]] --> Detect4[Detect P4<br>cv2:64<br>cv3:nc] P5[P5/32<br>[1,1024,20,20]] --> Detect5[Detect P5<br>cv2:64<br>cv3:nc] style Detect3 fill:#4CAF50,stroke:#388E3C,color:white style Detect4 fill:#2196F3,stroke:#0D47A1,color:white style Detect5 fill:#9C27B0,stroke:#4A148C,color:white

避坑提示：很多新手以为Detect输出就是[B, nc+4, H, W]，这是 YOLOv5 的耦合头。YOLOv8 是解耦的，cv2和cv3是两个独立分支，post-processing 时需分别处理。如果你要改 head（如加 CSL），必须同时修改cv2和cv3的输出逻辑，否则loss计算会报 dimension mismatch。

4. 避坑 / 常见问题 / 排查：画图过程中踩过的 5 个真实血泪坑

画 YOLOv8 结构图不是点几下鼠标就能搞定的事，它本质是调试模型理解的过程。以下是我在线上部署 RK3588、做 head 改进、排查 loss nan 时，反复撞墙又爬出来的 5 个高频坑。每一个都附带现象、根因和可立即执行的解决命令。

4.1 现象：torch.jit.trace报错TracingFailed: Couldn't trace function 'xxx'

原因：Ultralytics 某些模块（如C2f.forward）内含if分支或for循环，trace无法处理动态控制流。YOLOv8.0.192 之前，C2f用nn.Sequential(*[Bottleneck(...) for _ in range(n)])，trace会卡在range(n)。
解决：升级 Ultralytics 到 ≥ 8.0.200，新版C2f改用nn.ModuleList显式注册子模块，trace可捕获。验证命令：

pip install ultralytics --upgrade python -c "from ultralytics.nn.modules import C2f; print(C2f.__doc__)" # 应显示 'C2f module with ModuleList'

4.2 现象：生成的 SVG 图中大量prim::GetAttr节点，看不到C2f或Detect

原因：torch.jit.trace默认只 traceforward，而C2f的Bottleneck是通过getattr动态访问的，未被 trace 捕获。
解决：强制eval()并用torch.jit.script替代trace（对C2f等含 control flow 的模块更鲁棒）：

# 替换 gen_graph.py 中的 trace 部分 model.model.eval() scripted_model = torch.jit.script(model.model) # 注意：script 需要模型 forward 可被静态分析 scripted_model.save("yolov8n_scripted.pt")

4.3 现象：Mermaid 图中 P3/P4/P5 的 channel 数与model.info()输出不符

原因：model.info()显示的是C2f的c1参数（如C2f[128]），但实际输出 channel 是c2（由args[0]决定）。yolov8n.yaml中C2f的args=[128, True]，128是c2，c1是c2//2。
解决：永远以model.model.named_modules()输出为准：

model = YOLO('yolov8n.yaml').model for name, m in model.named_modules(): if 'C2f' in name: print(f"{name}: {list(m.children())[0].out_channels}") # 打印第一个 Conv 的 out_channels

4.4 现象：Detect模块在图中显示为aten::add，找不到cv2/cv3分支

原因：Detect.forward中cv2(x)和cv3(x)是两个独立调用，trace将其拆分为多个aten::conv2d节点，未聚合为cv2标签。
解决：手动在parse_graph.py中添加节点过滤，匹配cv2和cv3的 scopeName：

# 在 extract_node_info 函数中，替换 node.kind() 判断部分 if 'cv2' in node.scopeName() or 'cv3' in node.scopeName(): module_name = node.scopeName().split('.')[-2] # 如 'model.model.head.cv2'

4.5 现象：RK3588 部署时模型推理结果全为 0，但 PC 上正常

原因：结构图没画全——漏掉了Detect后的postprocess步骤。YOLOv8 的.pt模型输出是 raw logits（cv2/cv3），RK3588 的 NPU runtime（如 RKNN）通常只支持 inference，不支持non_max_suppression。PC 上model.predict()自动 postprocess，但 RK3588 需手动实现。
解决：在结构图末尾明确标注PostProcess模块，并导出onnx时用--task detect强制包含：

yolo export model=yolov8n.pt format=onnx dynamic=True task=detect # 然后用 rknn-toolkit2 转换，确保 onnx 中有 NMS 节点

5. 进阶技巧：用model.named_modules()定位任意层并注入钩子，实时观测 tensor 流动

画完静态图只是开始，真正的“看懂”结构，是在训练/推理时亲眼看到 tensor 怎么流过每一层。model.named_modules()是 PyTorch 最被低估的 API，它能让你在不改模型代码的前提下，给任意模块（如第 3 个C2f）挂上钩子（hook），打印输入输出 shape、统计梯度、甚至替换中间 tensor。这对 debugloss nan、验证C2f是否真的融合了特征、确认SPPF是否生效，效果立竿见影。

5.1 给 backbone 中的C2f模块挂前向钩子，观测特征图变化

目标：验证C2f是否真的将输入[1,128,160,160]转换为[1,128,160,160]（channel 不变，H/W 不变）。创建hook_demo.py：

# hook_demo.py import torch from ultralytics import YOLO model = YOLO('yolov8n.yaml').model model.eval() # 1. 找到所有 C2f 模块并编号 c2f_list = [] for name, module in model.named_modules(): if 'C2f' in name and not name.endswith('C2f'): # 排除 'C2f' 本身，取子模块如 'backbone.c2f_1' c2f_list.append((name, module)) print(f"Found {len(c2f_list)} C2f modules:") for i, (name, _) in enumerate(c2f_list): print(f" {i}: {name}") # 2. 给第 2 个 C2f（backbone 第 2 个，对应 P3/8）挂钩子 target_name = c2f_list[2][0] # 例如 'backbone.c2f_2' hook_data = {} def forward_hook(module, input, output): hook_data['input_shape'] = list(input[0].shape) if input else [] hook_data['output_shape'] = list(output.shape) if output is not None else [] print(f"✅ Hook triggered on {target_name}") print(f" Input: {hook_data['input_shape']} -> Output: {hook_data['output_shape']}") # 3. 注册钩子 for name, module in model.named_modules(): if name == target_name: handle = module.register_forward_hook(forward_hook) break # 4. 运行一次前向 dummy = torch.randn(1, 3, 640, 640) with torch.no_grad(): _ = model(dummy) # 5. 移除钩子（好习惯） handle.remove()

运行后输出类似：

✅ Hook triggered on backbone.c2f_2 Input: [1, 128, 160, 160] -> Output: [1, 128, 160, 16 <p> <a href="https://download.csdn.net/download/weixin_62200515/90683438" style="color:#ec7500;font-size:14px;"> 本文还有配套的精品资源，点击获取 </a> <img alt="menu-r.4af5f7ec.gif" src="https://csdnimg.cn/release/wenkucmsfe/public/img/menu-r.4af5f7ec.gif" style="width:16px;margin-left:4px;vertical-align:text-bottom;cursor:text;"> </p>