YOLO-World T-CSP Layer：开放词汇目标检测的视觉语言融合关键模块

之前在做开放词汇目标检测相关实验时，一直有一个比较头疼的问题：通用的检测模型只能识别训练集里出现过的类别，一旦换到新的业务场景，就要重新标注、重新训练，成本非常高。后来接触到 YOLO-World，发现它能通过文本描述来检测任意物体，真正把视觉特征和语言特征在模型内部打通。本文作为“多模态之 YOLO-World”系列的第 5 篇，重点拆解 YOLO-World 中一个容易被忽略但非常关键的模块：T-CSP Layer。

如果你已经看过前面几篇，对 YOLO-World 的整体结构、文本编码器、训练策略有一定了解，那这篇就是帮你把视觉-语言融合的细节彻底吃透。如果你是第一次接触 YOLO-World，也没关系，下文会先从背景和概念讲起，再逐步带你走到 T-CSP Layer 的代码层面。学完之后，你不仅知道 T-CSP Layer 长什么样，还能在自己的检测项目中改配置、加模块、做调试。

1. 背景与核心概念

1.1 为什么需要 YOLO-World

传统目标检测模型，比如 YOLOv5、YOLOv8，本质上都是“封闭集”检测。模型训练时给定固定的类别列表，例如 person、car、dog，推理时也只在这几个类别里做分类。这种方式在类别固定的场景下效果很好，但一旦类别发生变化，就不得不重新采集数据、重新训练，无法做到“即开即用”。

YOLO-World 的设计目标，是把目标检测从“封闭集”扩展到“开放词汇”。所谓开放词汇，指的是模型能够识别训练时没有见过的、由自然语言描述的物体类别。比如训练时模型没见过“teddy bear”这个词，但在推理阶段输入文本“teddy bear”，模型依然能在图像中把这个物体框出来。这种能力依赖视觉和语言的联合理解，因此 YOLO-World 通常被归类为多模态目标检测模型。

1.2 YOLO-World 的整体架构

YOLO-World 在实际部署中表现出一个很大优势：它以 YOLO 系列检测器为基础网络，因此继承了 YOLO 高吞吐、易部署的特点，同时加入文本编码器来引入语言信息。

从结构上看，YOLO-World 主要由三部分组成：

模块	作用
Text Encoder（文本编码器）	将类别文本转换成文本嵌入向量，例如用 CLIP 的文本编码器
Image Encoder（图像编码器）	提取图像视觉特征，通常基于 DarkNet、CSPDarkNet 等 Backbone
RepVL-PAN（可重参数化视觉-语言路径聚合网络）	融合视觉特征和文本特征，是 T-CSP Layer 所在的位置

T-CSP Layer 是 RepVL-PAN 中的一个子模块，承担着文本信息向视觉特征注入的关键任务。后面的章节会详细拆解它的设计与实现。

1.3 什么是 T-CSP Layer

T-CSP Layer，全称是 Text-guided Cross Stage Partial Layer，即“文本引导的跨阶段局部层”。这个名字里有三个关键点：

• Text-guided：说明这层的输入不仅仅是视觉特征，还会接收文本嵌入（text embedding），并用文本信息来指导下层的特征变换。
• Cross Stage Partial：沿用了 CSPNet（Cross Stage Partial Network）的设计思想，将特征图分成两个分支，一部分走主干计算，另一部分直接“抄近路”，从而在减少计算量的同时保持梯度流动。
• Layer：它是一个可复用的网络层模块，通常在多个尺度上都存在。

简单理解，T-CSP Layer 就是在 CSP 结构的基础上，额外增加了一条“文本引导”的旁路，让视觉特征在做跨阶段融合时，能够“看到”文本语义。这样，视觉特征会更有针对性地响应文本中描述的物体。

1.4 T-CSP Layer 与普通 CSP Layer 的区别

普通 CSP Layer 的输入和输出都是纯视觉特征，形式可以简化为：

x_out = CSP(x_vis)

而 T-CSP Layer 的输入包含视觉特征和文本嵌入：

x_out = TCSP(x_vis, text_embedding)

多出来的 text_embedding 会通过注意力机制、张量广播、融合模块等方式，影响视觉特征每个空间位置的响应。这样做的直接结果是：同一个视觉特征，在输入不同文本时，会生成不同的检测结果。这也是“开放词汇”能力从网络结构上得以实现的关键。

2. 环境准备与版本说明

2.1 运行环境

YOLO-World 目前官方开源代码主要基于 PyTorch，同时后续也支持了 Ultralytics YOLO 生态。日常开发中，我比较推荐下面这套环境组合：

依赖	建议版本/说明
操作系统	Ubuntu 20.04 / 22.04、Windows 10/11、macOS均可
Python	3.8 及以上
PyTorch	1.13 及以上，2.0 更佳
CUDA	10.2 及以上，建议 11.7 或更高
torchvision	与 PyTorch 版本对应
ultralytics	安装最新版即可，YOLO-World 的推理体验更友好

版本需要根据你的项目实际情况调整，本文示例以常见环境为例，重点演示配置思路，不强制依赖某个具体 commit。

2.2 安装依赖

建议先创建一个独立的 Python 虚拟环境，避免与已有项目产生冲突：

conda create -n yoloworld python=3.9 conda activate yoloworld pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118 pip install ultralytics

如果使用官方源码方式运行，可以执行：

git clone https://github.com/AILab-CVC/YOLO-World.git cd YOLO-World pip install -e .

这里不指定死版本号，因为仓库更新比较频繁，安装最新版本即可。

2.3 项目结构说明

以官方仓库为例，核心目录结构如下：

YOLO-World/ ├── configs/ │ └── pretrain/ │ └── yoloworld_v2_medium_vlpan.py ├── yoloworld/ │ ├── models/ │ │ ├── backbones/ │ │ ├── necks/ │ │ │ └── yoloworld_necks.py │ │ └── layers/ │ │ └── transformers.py ├── demo/ │ └── inference.py └── tools/ └── train.py

其中，T-CSP Layer 的实现通常写在yoloworld/models/layers/或yoloworld/models/necks/下面的模块文件中。不同版本的文件名可能不同，定位时优先在 necks 和 layers 目录下搜索CSPLayer或T-CSP相关关键词。

3. T-CSP Layer 设计思想与实现拆解

3.1 CSPNet 的设计精髓

要理解 T-CSP Layer，必须先理解 CSPLayer。CSP（Cross Stage Partial）的思想最早出自 CSPNet，目的是在不显著增加计算量的前提下，提高 CNN 的特征表达能力。它的基本结构是：

1. 将输入特征按通道分成两部分，一部分是shortcut分支，一部分是main分支。
2. main分支经过若干卷积、归一化、激活操作。
3. 最后把main分支和shortcut分支在通道维度上拼接起来，再经过一次卷积混合。

这种设计最直接的好处是梯度可以绕过主干计算层，直接流到前面的层，避免深层网络训练时的梯度消失问题，同时减少了重复计算。

在 YOLO 系列中，CSPLayer 已经是一个非常成熟的组件。它通常包含多个 Bottleneck 模块，通过控制shortcut和main分支的数量来平衡性能和速度。

3.2 从 CSPLayer 到 T-CSP Layer

当 YOLO-World 引入文本编码器之后，作者面临一个关键问题：文本嵌入应该从哪里进入视觉特征？

最初的方案可能是在检测头之前简单拼接文本向量，但这样文本信息只能在最后一刻影响分类，无法充分参与多尺度特征融合。更好的做法，是把文本信息嵌入到特征融合网络的每一层中，让模型在多个尺度上都能根据文本语义增强或抑制视觉特征。

于是，作者对 CSPLayer 做了改造，核心变化有两个：

• 增加文本嵌入输入。
• 在模块内部加入文本-视觉融合操作。

改造后的模块就是 T-CSP Layer。它可以放在 RepVL-PAN 的多个阶段中，对应不同的特征图尺度，从而让文本信息同时影响浅层细节和深层语义。

3.3 T-CSP Layer 的内部结构

下面是一个典型的 T-CSP Layer 结构描述，不绑定具体代码实现，但原理一致：

输入包括：

• 视觉特征x，形状是[B, C, H, W]
• 文本嵌入text_embedding，形状是[B, C_t]或[B, N, C_t]，其中N是文本数量。

处理流程可以分成以下几个子步骤：

1. 视觉特征主分支拆分。
2. 文本嵌入经过线性变换，对齐到视觉特征通道数。
3. 文本嵌入通过注意力或逐元素调制的形式，与视觉特征融合。
4. 融合后的特征继续经过瓶颈卷积组。
5. 与 shortcut 分支拼接，输出。

用公式表示更直观：

x1, x2 = split(x, dim=channel) text_proj = Linear(text_embedding) fused = x1 * text_proj.sigmoid() # 逐通道调制 out = Conv(Bottleneck(fused)) out = Concat([out, x2]) out = Conv(out)

这里给出的是最基本的缩放调制方式。实际代码中可能会用到 Multi-Head Attention、Cross-Attention 等更复杂的融合方式，但核心思想都是让文本信息“指导”视觉特征。

3.4 为什么使用文本引导而不是简单拼接

如果你尝试过在多模态模型里直接拼接文本向量，很可能会遇到一个问题：文本向量的维度通常较小，而且与视觉特征的空间位置没有直接对应关系，拼接后网络很难学到稳定有效的融合。

T-CSP Layer 采用文本引导的方式，让文本嵌入先经过可学习的映射，再对视觉特征的每个通道或者每个空间位置进行调制。这种方式相当于为视觉特征加上了“语义开关”：当文本描述的是“person”时，网络会增强人形目标的特征响应；当文本描述的是“car”时，又会切换到车辆相关特征。

因此，T-CSP Layer 解决的不只是“能否看见文本”的问题，而是“文本能否精准影响视觉特征分布”的问题。

3.5 代码示意：一个简单的 T-CSP Layer

为了更清晰地说明实现逻辑，这里用一个简化版 PyTorch 模块来演示。实际官方实现会更复杂，但核心流程基本一致。

# 文件路径：models/tcsp_layer.py import torch import torch.nn as nn class ConvBlock(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=1, stride=1): super().__init__() self.conv = nn.Conv2d( in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=kernel_size // 2, bias=False, ) self.bn = nn.BatchNorm2d(out_channels) self.act = nn.SiLU(inplace=True) def forward(self, x): return self.act(self.bn(self.conv(x))) class Bottleneck(nn.Module): def __init__(self, in_channels, out_channels, shortcut=True): super().__init__() self.cv1 = ConvBlock(in_channels, out_channels, kernel_size=1) self.cv2 = ConvBlock(out_channels, out_channels, kernel_size=3) self.shortcut = shortcut and in_channels == out_channels def forward(self, x): residual = x out = self.cv1(x) out = self.cv2(out) if self.shortcut: out = out + residual return out class TCSPLayer(nn.Module): def __init__( self, in_channels, out_channels, text_channels=512, num_bottlenecks=1, shortcut=True, ): super().__init__() mid_channels = out_channels // 2 self.cv1 = ConvBlock(in_channels, mid_channels, kernel_size=1) self.cv2 = ConvBlock(in_channels, mid_channels, kernel_size=1) self.cv3 = ConvBlock(mid_channels * 2, out_channels, kernel_size=1) # 文本引导适配层 self.text_proj = nn.Linear(text_channels, mid_channels) # 注意力调制：生成每个通道的缩放因子 self.text_fc = nn.Sequential( nn.Linear(mid_channels, mid_channels), nn.SiLU(inplace=True), nn.Linear(mid_channels, mid_channels), nn.Sigmoid(), ) self.bottlenecks = nn.ModuleList( [ Bottleneck(mid_channels, mid_channels, shortcut=shortcut) for _ in range(num_bottlenecks) ] ) def forward(self, x, text_embedding): # x: [B, C, H, W] # text_embedding: [B, C_t] main = self.cv1(x) shortcut = self.cv2(x) # 文本嵌入映射到视觉通道数 text_feat = self.text_proj(text_embedding) # [B, mid_channels] scale = self.text_fc(text_feat) # [B, mid_channels] # 按通道调制主分支 scale = scale.unsqueeze(-1).unsqueeze(-1) # [B, mid_channels, 1, 1] main = main * scale for bottleneck in self.bottlenecks: main = bottleneck(main) out = torch.cat([main, shortcut], dim=1) out = self.cv3(out) return out if __name__ == "__main__": model = TCSPLayer(in_channels=256, out_channels=256, text_channels=512) x = torch.randn(2, 256, 32, 32) text_emb = torch.randn(2, 512) y = model(x, text_emb) print(y.shape) # torch.Size([2, 256, 32, 32])

这个示例展示了 T-CSP Layer 最核心的操作：

• 将视觉特征拆分。
• 使用文本嵌入生成通道缩放因子。
• 用缩放因子调制主分支。
• 继续经过 Bottleneck 提取特征。
• 最后与 shortcut 分支拼接并输出。

实际工程中，文本嵌入可能不止一个，而是多个类别的嵌入，此时需要设计更复杂的融合逻辑，但上面的思路完全可以作为理解和二次开发的起点。

3.6 RepVL-PAN 中的多尺度融合

T-CSP Layer 不是孤立的模块，它位于 RepVL-PAN 的不同 stage 中。RepVL-PAN 的职责是进行自顶向下和自底向上的多尺度特征传递。每个尺度上，视觉特征都会和文本嵌入做一次融合，从而保证小目标和大目标都能获得语言信息的指导。

多尺度融合的好处是显而易见的：

• 浅层特征分辨率高，经过 T-CSP Layer 后，文本信息可以影响边缘、纹理等细节。
• 深层特征语义强，经过 T-CSP Layer 后，文本信息可以强化类别相关的全局语义。

这也是为什么 YOLO-World 在多种目标尺度上都能保持较好的开放词汇检测能力。

4. YOLO-World 实战：加载模型并观察 T-CSP Layer 效果

4.1 使用官方预训练权重执行推理

在你动手修改 T-CSP Layer 之前，建议先跑通官方推理流程，建立直观感知。下面使用 Ultralytics 的方式加载 YOLO-World 模型：

# 文件路径：infer_demo.py from ultralytics import YOLOWorld # 加载预训练模型 model = YOLOWorld("yolov8s-worldv2.pt") # 定义开放词汇类别 model.set_classes(["person", "bus", "car", "traffic light"]) # 推理 results = model.predict( "bus.jpg", conf=0.3, show=True, save=True, )

执行完上面的代码，模型会输出检测结果图片，并保存到runs/detect/predict目录。如果图片中出现了 person、bus、car 等目标，就说明 YOLO-World 的基本流程已经跑通了。

4.2 自定义类别检测

YOLO-World 最大的优势是支持自定义文本类别，不需要重新训练。比如场景换成了工厂质检：

model.set_classes(["defect", "scratch", "stain"])

这时模型会尝试在图像中寻找“defect”、“scratch”、“stain”对应的目标。这里的类名会被文本编码器转换成 embedding，然后送入 T-CSP Layer，影响检测结果。

有一点需要说明：虽然不需要训练，但开放词汇检测的精度仍然受预训练数据影响。如果你的类别非常冷门，比如某种特定型号的零件，可能需要进一步微调模型才能得到满意效果。

4.3 查看模型结构中的 T-CSP Layer

用 PyTorch 的named_modules可以快速定位 T-CSP Layer 在模型中的位置：

# 文件路径：inspect_model.py from ultralytics import YOLOWorld model = YOLOWorld("yolov8s-worldv2.pt") for name, module in model.model.named_modules(): if "csp" in name.lower() or "tcsp" in name.lower(): print(name, type(module))

不同版本的 YOLO-World 模型命名可能不同，但重点关注名字里包含csp或tcsp的模块即可。如果某个模块的输入除了x之外还有一个text_embedding参数，那它很可能就是 T-CSP Layer。

4.4 修改配置文件启用或关闭 T-CSP Layer

如果你使用的是官方源码配置，可以在模型中看到 RepVL-PAN 的相关配置。以常见的 MLN 和 T-CSP 组合为例，配置文件中会有类似下面的结构：

model = dict( type='YOLOWorldDetector', ... neck=dict( type='RepVL_PAN', out_channels=[256, 512, 1024], # 这里控制是否使用文本引导 use_text_guided_csp=True, text_channels=512, ), )

不同版本的字段名会有所不同，但思路相同。你可以通过修改use_text_guided_csp或类似的开关，对比开启和关闭 T-CSP Layer 时的推理效果。

如果想彻底替换成普通 CSPLayer，也可以把RepVL_PAN中 T-CSP 相关分支注释掉，换成传统的CSPLayer。但需要注意，替换后文本嵌入就失去了注入点，模型将不再具备开放词汇检测能力。

4.5 测试 T-CSP Layer 对结果的影响

为了直观感受 T-CSP Layer 的作用，你可以做一个小实验：

1. 用原始 YOLO-World 模型检测一张图。
2. 在推理脚本中手动把text_embedding置为全零向量。
3. 再次检测同一张图。

如果 T-CSP Layer 生效，第二次推理的结果很可能会发生变化，甚至大量目标无法检出。这个实验可以帮你验证模块是否存在以及是否正常工作。

简化的实验代码如下：

# 文件路径：test_zero_text.py import torch from ultralytics import YOLOWorld model = YOLOWorld("yolov8s-worldv2.pt") # 手动将文本 embedding 置零（这里仅为演示思路，具体接口以版本为准） text_emb = model.text_embedding model.text_embedding = torch.zeros_like(text_emb) results = model.predict("bus.jpg", conf=0.3)

这种方式不一定在所有版本里都通用，但可以作为理解 T-CSP Layer 功能入口的一个角度。

5. 常见问题与排查思路

在实际使用和二次开发 YOLO-World 时，很容易在环境、配置、文本编码和模块修改环节踩坑。下面整理了一份高频问题清单。

问题现象	常见原因	解决思路
推理时提示缺少文本编码器或 CLIP 权重	环境变量未设置，或权重文件未下载完整	检查网络环境，手动下载对应权重并放到指定目录
修改自定义类别后检测效果很差	类别描述与训练数据差异较大，或文本编码器输入格式不规范	尝试添加更具体的描述词，例如“red bus”而不是“bus”
开启 T-CSP Layer 后显存占用增加	文本-视觉融合模块引入了额外参数和计算	检查是否每个 stage 都使用了大通道数，可适当减少文本融合头数量
从 YOLOv8 切到 YOLO-World 时结构对不上	官方代码版本更新，模块名称变化	搜索源码中CSPLayer、TCSP、text_guided等关键词定位
自定义文本类别超出词汇表限制	文本编码器使用的是 CLIP 词表，不支持某些生僻词	换成 CLIP 能理解的表达方式，或微调文本编码器
模型训练时 T-CSP Layer 梯度不稳定	学习率过高或文本模态与视觉模态收敛速度不匹配	尝试降低初始学习率，或者为文本分支单独设置较低学习率

5.1 文本类别长度问题

YOLO-World 支持输入多个文本类别，每个类别通常是一个短语。如果类别短语太长，比如“a person wearing a red hat and carrying a black bag”，文本编码器的输出特征可能会包含过多信息，反而不利于检测。

建议的做法是：把复杂类别拆分成短类别，或者使用多个描述词组合，例如：

model.set_classes(["person", "red hat", "black bag"])

这样 T-CSP Layer 可以更明确地分别响应不同语义，而不是试图在一个 embedding 里混合过多信息。

5.2 训练阶段 T-CSP Layer 的冻结策略

如果你只需要检测能力，不打算微调整个模型，可以在训练时冻结 Backbone 和文本编码器，只训练检测头与 T-CSP Layer。这样可以大幅减少训练时间，同时保留开放词汇能力。

一个常见的冻结思路如下：

for name, param in model.named_parameters(): if "backbone" in name or "text_encoder" in name: param.requires_grad = False

不过，具体哪些层需要冻结，还是要根据你的数据集和业务目标来决定。如果目标域与预训练数据差异很小，冻结 Backbone 是划算的；如果差异很大，建议全量微调。

5.3 多卡训练时的文本嵌入同步

在分布式训练 YOLO-World 时，文本嵌入通常是公共参数，不随 batch 变化。但在一些实现中，文本编码器可能独立于数据并行模块。如果你的训练脚本出现文本嵌入不一致的问题，可以考虑把文本嵌入在每次迭代前通过broadcast同步到所有 GPU。

这部分与 T-CSP Layer 本身关系不大，但在工程落地中很重要，提前注意可以少踩很多坑。

6. 最佳实践与工程建议

6.1 不要把 T-CSP Layer 单纯当成一个“黑盒模块”

从模型设计的角度看，T-CSP Layer 是开放词汇能力的核心载体之一。如果只把它当作普通卷积层来用，遇到效果不佳时就会束手无策。建议从输入输出张量的形状变化开始追踪，逐步理解文本 embedding 是如何影响检测结果的。

你可以打印中间层输出进行观察：

# 观察 T-CSP Layer 输入输出 def hook_fn(module, input, output): print(f"module: {module.__class__.__name__}") print(f"input[0] shape: {input[0].shape}") print(f"output shape: {output.shape}") model.model.register_forward_hook(hook_fn)

这是我个人比较推荐的调试方法：先确认模块是否被正确调用，再分析张量形状和值分布。

6.2 为不同业务场景设计文本类别

开放词汇检测的能力上限，不仅取决于模型结构，还取决于输入文本的质量。下面是一个经验性的类别描述建议：

场景	简单类别	更好的类别描述
车辆检测	car	car, sedan, suv, truck
工业质检	defect	scratch, dent, stain, crack
安防监控	person	person, pedestrian, rider
零售商品	bottle	plastic bottle, glass bottle, can

在 T-CSP Layer 的视角下，类别文本会被编码成向量，再调制视觉特征。更精确的描述可以让文本嵌入的语义与视觉特征更匹配。

6.3 考虑推理速度与精度的平衡

T-CSP Layer 虽然参数不算大，但在多个尺度堆叠后，仍然会带来一定的计算开销。如果部署环境是边缘设备，比如 Jetson、树莓派，建议：

• 减少 stage 中的 T-CSP Layer 数量。
• 使用 ONNX / TensorRT 导出模型。
• 尽量使用 int8 量化。
• 对文本 embedding 做缓存，避免每次推理都重新计算。

文本 embedding 可以在检测类别固定的场景下提前计算并缓存，因为同一个文本类别对应的 embedding 是固定的。这样可以跳过文本编码器，只保留 T-CSP Layer 对缓存 embedding 的读取，速度提升非常明显。

6.4 使用缓存文本嵌入加速推理

在固定类别场景下，文本编码器是重复计算最严重的部分。一个很好的工程优化是：预先计算所有类别的 embedding，保存为文件，推理时直接加载。

# 文件路径：prepare_text_embeddings.py import torch from ultralytics import YOLOWorld model = YOLOWorld("yolov8s-worldv2.pt") classes = ["person", "car", "bus", "traffic light"] text_embeddings = model.encode_text(classes) # 根据版本调整 API torch.save(text_embeddings, "text_embeddings.pt")

然后在推理脚本中直接加载，避免每次调用文本编码器：

# 文件路径：infer_fast.py import torch from ultralytics import YOLOWorld text_embeddings = torch.load("text_embeddings.pt") model = YOLOWorld("yolov8s-worldv2.pt") model.set_text_embeddings(text_embeddings) # 需要根据实现情况适配

这个优化对 T-CSP Layer 的使用没有副作用，因为 T-CSP Layer 读取的只是最终文本嵌入向量，并不关心这个向量是实时编码还是缓存获取的。

6.5 注意安全与合规边界

在实际项目中，尤其是面向 C 端或复杂业务环境时，使用开放词汇检测模型需要特别注意合规性。采集的图像数据应获得合法授权，检测的类别也不能包含任何违法违规内容。作为开发者，我们应当在合法授权、最小必要权限和可追溯的前提下使用多模态目标检测能力。

7. 总结与后续学习路线

本文围绕 YOLO-World 的 T-CSP Layer，从概念、结构、代码示意到工程优化做了一个比较完整的拆解。你至少应该掌握以下几点：

• T-CSP Layer 是文本引导的 CSP 模块，本质是在传统 CSP 结构中加入文本嵌入调制。
• 它位于 RepVL-PAN 中，负责在不同尺度上融合视觉特征和文本语义。
• 文本嵌入通过可学习的映射生成通道级调制因子，从而影响视觉特征的响应。
• 工程上可以通过文本嵌入缓存、模块冻结、模型导出等方式优化部署效果。

如果你接下来想继续深入，可以考虑以下方向：

1. 阅读 YOLO-World 源码中RepVL-PAN的完整实现，把 T-CSP Layer 的每个子模块都过一遍。
2. 尝试把 YOLO-World 的文本编码器换成语义更强的模型，比如更大的 CLIP 变体，观察检测效果变化。
3. 在自定义数据集上微调 YOLO-World，并比较冻结不同模块时的精度差异。
4. 尝试将 T-CSP Layer 的思想迁移到其他单阶段目标检测器中，实现自己的开放词汇检测方案。

多模态目标检测是一个快速演进的领域，YOLO-World 的 T-CSP Layer 提供了一种非常务实的视觉-语言融合方式。希望这篇教程能帮助你在自己的项目中更好地使用和改造它。