meaning dataset
Meaning Dataset 详细介绍文档
目录
概述
meaning数据集Meaning Dataset 是一个模仿自然语言，以及结构和抽象表达的数据集。它通过层级化的树形结构来表示语义（meaning），其中每个复杂的语义都可以分解为更简单的语义单元，最终分解为不可再分的基本单元（token）。
设计理念
层级化语义表示
每个 meaning 都有一个唯一编号，编号的大小直接反映其复杂度：
- 小编号 = 简单语义（如基本概念）
- 大编号 = 复杂语义（由多个简单语义组合而成）
这种设计模仿了人类认知的层级特性——复杂概念总是建立在简单概念之上。
可组合性原理
所有复杂的 meaning 都可以由更低编号的 meaning 组合而成。这种递归分解的特性确保了：
- 任何语义都可以追溯到底层的基本单元
- 分解过程形成树形结构
- 同一个 meaning 可以作为多个更复杂 meaning 的组成部分
自然语言模拟
Meaning Dataset 模仿了自然语言的核心特征：
- 词汇表：基本的 token 类似于单词
- 语法：meaning 的组合规则类似于语法结构
- 递归性：有限的基本单元可以组合出无限的复杂表达
核心概念
Token（词元）- 原子语义单元
Token 是整个 meaning 系统中最基本的、不可再分的数据表达单元。
特征：
- 编号范围：0 到 vocab_size - 1
- 不可被拆解或分解
- 是所有 meaning 分解的最终层级
- 类似自然语言中的"单词"
类比：就像自然语言中，"苹果"、"红色"、"吃"这些单词无法再分解为更小的有意义的单位。
Meaning（语义）- 可组合的语义单位
Meaning 是一种语义或符号的表达，用唯一编号标识。
编号规则：
| 编号范围 | 类型 | 特性 |
|---|---|---|
| 0 ~ vocab_size-1 | 基本 meaning | 即 token，不可拆解 |
| vocab_size 及以上 | 复合 meaning | 可拆解为更低编号的 meaning |
复杂度递增：编号越大，表示语义越复杂。这是因为：
- 大编号的 meaning 可以选择更多的"原材料"（小编号 meaning）进行组合
- 组合的层级可能更深
类比：在自然语言中：
- "花" = 基本语义（token）
- "玫瑰花" = 复合语义（"玫瑰" + "花"）
- "红玫瑰花园" = 更复杂的语义（由更简单的语义组合而成）
Level（层级）- 语义深度
Level 表示当前 token 相对于 root meaning 的距离，反映了语义的深度。
层级定义：
- Level 0：token 层，基本单元层
- Level 1：由 token 直接组合成的 meaning
- Level 2：由 Level 1 的 meaning 组合成的 meaning
- 以此类推...
可视化：
Level 3: Meaning A
/ \
Level 2: Meaning B Meaning C
/ \ / \
Level 1: Token Token Meaning D Token
/ \
Level 0: Token Token
特殊 Level 值：
| 值 | 含义 | 用途 |
|---|---|---|
| 0 | 基本层 | token 所在的层 |
| 255 | Tree 标记 | 标识树节点位置（with_tree 模式） |
| 511 | Stride 标记 | 标识重复的 token（stride 模式） |
Meaning Height（高度）- 树的深度
Meaning Height 是当前 meaning 从根节点到叶节点的最大层级深度。
意义：
- Height 越大，表示该 meaning 的语义结构越复杂
- Height 反映了分解的层级数量
- Height = 1 表示只由 token 直接组成
- Height > 1 表示存在多层嵌套结构
示例：
Meaning A (Height = 1):
└── Token1, Token2, Token3
Meaning B (Height = 2):
└── Meaning C (Height = 1)
└── Token1, Token2
└── Token3
Meaning C (Height = 3):
└── Meaning D (Height = 2)
└── Meaning E (Height = 1)
└── Token1, Token2
└── Token3
└── Token4
Meaning Weight（宽度）- 叶节点数量
Meaning Weight 是当前 meaning 的叶节点（token）总数，也称为序列长度。
意义：
- Weight 越大，表示该 meaning 包含的基本单元越多
- Weight 直接决定了序列的长度
- Weight 与 Height 无直接关系——一个 shallow but broad 的 meaning 可能有很大 weight
示例：
Meaning A (Weight = 5):
├── Token1
├── Token2
├── Token3
├── Token4
└── Token5
(Height = 1, Weight = 5)
Meaning B (Weight = 5):
└── Meaning C
└── Meaning D
└── Meaning E
└── Token1, Token2, Token3, Token4, Token5
(Height = 4, Weight = 5)
语义层级结构
树形分解结构
每个 meaning 通过层层递归分解形成树形数据结构：
- 根节点：原始 meaning
- 中间节点：中间层的 meaning
- 叶节点：基本 token
前序遍历序列化
树形结构通过前序遍历（pre-order traversal）展开为线性序列：
遍历规则：
- 访问当前节点的第一个子项
- 递归访问该子项的所有子项
- 返回并访问当前节点的第二个子项
- 重复直到所有子项被访问
示例：
树形结构：
A
/ | \
B C D
/\ |
E F G
前序遍历序列：B, E, F, C, G, D
Meaning 分解规则
基本 Meaning（0 到 vocab_size-1）
- 直接映射为自身
- 不进行分解
- Level = 0
- 序列只包含自身
复合 Meaning（>= vocab_size）
复合 meaning 的生成遵循以下规则：
-
子项选择：从 [0, current_meaning) 范围内随机选择子项
- 确保子项编号小于父项，满足"编号越小越简单"的原则
- 可以选择 token 或其他复合 meaning
-
子项数量：在 [min_subitem, max_subitem] 之间
- min_subitem：最少子项数
- max_subitem：最多子项数
- 实际数量随机决定
-
递归分解：
- 对于每个子项，如果是复合 meaning，递归获取其序列
- 如果是 token，直接使用其值
-
序列拼接：
- 按子项顺序拼接所有子序列
- 计算每个位置的新 level、rank_idx、rank_all
-
层级计算：
- 新 level = 子项 level + 1
- 这样逐层递增，形成层级结构
Level 传播机制
Level 信息随着 meaning 的分解逐层传播：
传播规则：
父 meaning 的 level = 子 meaning 的 level + 1
示例：
Meaning 1000 (Level 在序列中为 1)
├── Meaning 500 (Level 在序列中为 2)
│ ├── Token 10 (Level 在序列中为 3)
│ └── Token 20 (Level 在序列中为 3)
└── Token 30 (Level 在序列中为 2)
序列：[500(分解), 30]
实际上序列展开为：[10, 20, 30]
Level： [3, 3, 2]
可视化：
Level 0: ████████████████ (Token 层)
Level 1: ██████ (第一层组合)
Level 2: ████ (第二层组合)
Level 3: ██ (第三层组合)
Rank 编码机制
Rank 编码是 meaning 系统的核心机制，用于精确定位每个 token 在树形结构中的位置。
设计目标
Rank 编码需要解决两个问题：
- 位置定位：token 在每一层中的位置是什么？
- 分支信息：每一层有多少个分支？
Rank_idx（排序索引）- 位置编码
Rank_idx 记录了 token 在每一层中的位置信息。
编码方式：
- 每层使用 4 位存储（0-15）
- 低 4 位：第 0 层（最底层）的位置
- 第 5-8 位：第 1 层的位置
- 第 9-12 位：第 2 层的位置
- 以此类推...
编码公式：
rank_idx = (pos_0) | (pos_1 << 4) | (pos_2 << 8) | ...
示例解析：
rank_idx = 273 = 0x111
二进制：0001 0001 0001
层2 层1 层0
含义：
- 第 0 层位置：1 (二进制 0001)
- 第 1 层位置：1 (二进制 0001)
- 第 2 层位置：1 (二进制 0001)
填充规则：
- 高位无效位用 1（0xF）填充
- 这样可以区分有效数据和填充位
Tree Token 特殊处理：
- Tree token 总是排在当前层的最后
- 其 rank_idx 为 0xFFFFFFF0 + m_len
- m_len 是当前层的子项数量
Rank_all（排序总数）- 分支计数
Rank_all 记录了每一层的总分支数量。
编码方式：
- 每层使用 4 位存储（0-15）
- 与 rank_idx 相同的位布局
- 每一层的值表示该层的分支总数
编码公式：
rank_all = (count_0) | (count_1 << 4) | (count_2 << 8) | ...
示例解析：
rank_all = 4369 = 0x1111
二进制：0001 0001 0001 0001
层3 层2 层1 层0
含义：
- 第 0 层总数：1
- 第 1 层总数：1
- 第 2 层总数：1
- 第 3 层总数：1
计算规则：
- Token 层（level 0）：rank_all = 0xFFFFFFF（填充）
- 复合 meaning：rank_all = (子项 rank_all << 4) + 当前子项数
Tree Token 特殊处理：
- Tree token 不计入 rank_all 总数
- 其 rank_all 也为 0xFFFFFFF0 + m_len
Rank 计算示例
考虑以下树形结构：
A (rank_idx=?, rank_all=?)
/ | \
B C D
/\ |
E F G
计算过程：
-
叶节点（E, F, G）：
- 都是 token（level 0）
- rank_idx = 0, 1, 0（各自在父节点中的位置）
- rank_all = 0xFFFFFFF（填充值）
-
中间节点（B, C, D）：
- B 有 2 个子项（E, F）
- C 有 1 个子项（G）
- D 是 token
- rank_idx(B) = 0 | (0 << 4) = 0（第 0 层第 0 个）
- rank_all(B) = 0xF | (2 << 4) = 0x2F（第 1 层有 2 个）
-
根节点（A）：
- 有 3 个子项（B, C, D）
- rank_idx(A) = 0 | (0 << 4) | (0 << 8) = 0
- rank_all(A) = 0xF | (0xF << 4) | (3 << 8) = 0x3FF
Rank 的用途
1. 位置查询： 通过 rank_idx 和 rank_all 可以快速判断：
- token 是否在某层的某个位置
- token 是否在某层的第一个/最后一个
2. 结构分析：
- 通过 rank_all 知道每层的分支数
- 通过 rank_idx 知道 token 在每层的相对位置
3. 训练 Mask： 可以使用 rank 信息精确控制哪些 token 参与训练：
val_mask_level = [0, 1] # 只看第 0 层和第 1 层
val_mask_idx = [0, -1] # 第 0 层第 0 个，第 1 层最后 1 个
序列生成机制
序列展开过程
将 meaning 树展开为线性序列的过程：
步骤 1：从根 meaning 开始 步骤 2：获取 meaning 的所有子项 步骤 3：对每个子项：
- 如果是 token，直接加入序列
- 如果是复合 meaning，递归展开后加入序列 步骤 4：按子项顺序拼接所有结果
信息携带
序列中的每个位置携带多种信息：
| 信息 | 描述 | 用途 |
|---|---|---|
| token | 基本单元的值 | 模型的输入 |
| level | 当前 token 的层级 | 理解结构深度 |
| rank_idx | 当前 token 在各层的位置 | 定位和结构分析 |
| rank_all | 各层的分支总数 | 结构完整性信息 |
约束条件
为了保证 rank 编码的有效性，系统有以下约束：
| 约束 | 值 | 原因 |
|---|---|---|
| 每层最多子项数 | 15 | rank 使用 4 位存储 |
| 最大层级数 | 8 | rank 总共 32 位，每层 4 位 |
| token 范围 | 0 ~ vocab_size-1 | 词汇表大小限制 |
特殊功能机制
Stride（步长）功能
目的：通过重复 token 来模拟某种强调或时序特性。
机制：
- 当 stride > 1 时，每个 token 会被重复指定次数
- 重复的 token 被标记为 level = 511（特殊 level）
- 原始 token 保持 level = 0
示例：
stride = 2
原始序列：[A, B, C]
扩展后： [A, A', B, B', C, C']
Level： [0, 511, 0, 511, 0, 511]
用途：
- 模拟某种强调或重复模式
- 增加序列长度而不增加语义复杂度
- 测试模型对重复模式的处理能力
With Tree 功能
目的：在序列中显式标记树形结构的位置。
机制：
- 每个 meaning 的子项展开后，在末尾插入一个 tree token
- Tree token 使用特殊的 level = 255
- Tree token 的编号为 vocab_size - special_vocab_offset
示例：
without_tree:
Meaning A 有子项 [B, C]
序列：[B(展开), C(展开)]
with_tree:
序列：[B(展开), TREE, C(展开), TREE]
可视化：
Tree: A
/ \
B C
序列：[B1, B2, TREE, C1, C2, C3, TREE]
└─B的部分──┘ └──C的部分───┘
用途：
- 为模型提供显式的结构边界信息
- 帮助模型理解语义的组合关系
- 类似自然语言中的括号或标点符号
验证 Mask（Validation Mask）
目的：精确控制哪些 token 参与训练损失计算。
机制：
- 通过 level 和 idx 两个维度进行筛选
- 可以组合多个条件（AND 逻辑）
- 只有满足所有条件的 token 才会参与训练
配置方式：
val_mask_level = [0, 1, 2] # 指定层级
val_mask_idx = [0, 0, -1] # 指定每层的位置
含义：
- 第 0 层的第 0 个 token
- 且第 1 层的第 0 个 token
- 且第 2 层的最后 1 个 token
- 只有同时满足这 3 个条件的 token 才参与训练
用途：
- 训练特定位置的 token 预测能力
- 研究模型对不同层级信息的利用情况
- 实现课程学习（先学简单的，再学复杂的）
Mask 类型：
| 类型 | 描述 | 用途 |
|---|---|---|
| token_mask | 区分正常 token 和特殊 token | 过滤 stride/tree token |
| val_mask | 根据位置筛选 token | 控制训练目标 |
数据示例
完整示例
以下是一个完整的 meaning 树及其展开序列：
配置：
vocab_size = 256
meaning = 115200
树形结构：
115200
/ | \
10240 1100 12322
/ | \ / \ / | \
512 32 1201 245 233 3214 532 324
/ \ / \ / \ | / \
123 42 320 500 1231 23 324 93 176
/ \ / \ / \ / \
176 11 255 129 129 99 211 111
展开序列：
序列内容： 123 42 32 176 11 255 129 245 233 129 99 23 211 111 93 176
level： 3 3 2 4 4 4 4 2 2 4 4 3 4 4 3 3
rank_idx： 0 1 1 0 1 16 17 16 17 0 1 2 0 1 32 33
at L0： 0 1 1 0 1 0 1 0 1 0 1 2 0 1 0 1
at L1： 0 0 0 0 0 1 1 1 1 0 0 0 0 0 2 2
Rank 编码详解
以序列中的几个位置为例：
位置 0 (token=123)：
- level = 3：在 3 层深度
- rank_idx = 0：
- 第 0 层：位置 0
- 第 1 层：位置 0
- 第 2 层：位置 0
- 含义：这是 512 → 123 这个分支的第一个 token
位置 3 (token=176)：
- level = 4：在 4 层深度（最深）
- rank_idx = 0：
- 第 0 层：位置 0
- 第 1 层：位置 0
- 第 2 层：位置 0
- 第 3 层：位置 0
- 含义：这是 320 → 176 这个分支的第一个 token
位置 14 (token=93)：
- level = 3
- rank_idx = 32 = 0x20：
- 第 0 层：位置 0
- 第 1 层：位置 0
- 第 2 层：位置 2
- 含义：这是 324 的第 2 个子项（子项：324, 93, 176）
实际树形可视化
90800
├── 17100
│ ├── 3078
│ │ ├── 153
│ │ │ ├── <25>
│ │ │ ├── 34
│ │ │ │ ├── <11>
│ │ │ │ └── <0>
│ │ │ ├── 39
│ │ │ │ ├── <3>
│ │ │ │ └── <7>
│ │ │ ├── <15>
│ │ │ └── 37
│ │ │ ├── <8>
│ │ │ ├── <10>
│ │ │ └── <7>
│ │ ├── 848
│ │ │ ├── 212
│ │ │ │ ├── 53
│ │ │ │ │ ├── <14>
│ │ │ │ │ └── <13>
│ │ │ │ └── 60
│ │ │ │ ├── <1>
│ │ │ │ ├── <12>
│ │ │ │ └── <13>
│ │ │ └── 124
│ │ │ ├── <12>
│ │ │ ├── <13>
│ │ │ ├── <24>
│ │ │ └── 32
│ │ │ ├── <5>
│ │ │ ├── <8>
│ │ │ ├── <8>
│ │ │ ├── <7>
│ │ │ └── <1>
│ │ └── 299
│ │ ├── 66
│ │ │ ├── <18>
│ │ │ ├── 38
│ │ │ │ ├── <1>
│ │ │ │ ├── <11>
│ │ │ │ ├── <11>
│ │ │ │ ├── <8>
│ │ │ │ └── <4>
│ │ │ ├── <0>
│ │ │ ├── <5>
│ │ │ └── <2>
│ │ ├── 61
│ │ │ ├── <20>
│ │ │ ├── <10>
│ │ │ ├── <6>
│ │ │ └── <16>
│ │ ├── 46
│ │ │ ├── <14>
│ │ │ └── <9>
│ │ └── 37
│ │ ├── <8>
│ │ ├── <10>
│ │ └── <7>
...
图例：
<>中的数字：token 的序列索引位置- 普通数字：meaning 的编号
统计特性
对于 vocab_size = 256, size = 115200 的配置：
| 指标 | 典型值 | 说明 |
|---|---|---|
| 总 meaning 数 | 115200 | 包含基本 token 和复合 meaning |
| 基本 token 数 | 256 | vocab_size |
| 最大序列长度 | 50-200 | 取决于分解规则 |
| 平均序列长度 | 20-50 | 取决于 min/max_subitem |
| 最大层级深度 | 4-8 | 取决于随机分解结果 |
| 最常见序列长度 | 10-30 | 大多数 meaning 的复杂度 |
设计优势
1. 层次化表达
Meaning Dataset 通过层级结构自然地表达了语义的组合性和层次性，这与人类认知和自然语言的结构高度一致。
2. 可控复杂度
通过调整参数，可以控制：
- 语义的复杂度范围（start, end）
- 分解的粒度（min_subitem, max_subitem）
- 结构的深度（间接控制）
3. 丰富的结构信息
每个 token 携带多层信息：
- 值信息（token 本身）
- 结构信息（level）
- 位置信息（rank_idx）
- 上下文信息（rank_all）
4. 灵活的训练控制
通过验证 mask，可以：
- 训练特定层级的预测能力
- 实现课程学习
- 研究模型对不同结构信息的利用
5. 可扩展性
系统支持多种扩展：
- Stride：增加时序维度
- With Tree：增加显式结构标记
- 自定义 mask：实现各种训练策略
与自然语言的类比
| Meaning Dataset | 自然语言 | 说明 |
|---|---|---|
| Token | 单词 | 基本表达单元 |
| Meaning | 词组/句子 | 由单词组合成的有意义的单位 |
| Level | 嵌套深度 | 句法结构的嵌套层级 |
| Rank_idx | 词序/句法位置 | 单词在短语/句子中的位置 |
| Rank_all | 分支数 | 可选的并列成分数量 |
| Tree | 句法树 | 语法结构的树形表示 |
| Sequence | 线性文本 | 树形结构展开后的线性形式 |
这种类比使得 Meaning Dataset 成为研究语言模型对结构化信息处理能力的理想工具。