Skip to main content

Meaning Dataset 详细介绍文档

目录

  1. 概述
  2. 核心概念
  3. 语义层级结构
  4. Rank 编码机制
  5. 序列生成机制
  6. 特殊功能机制
  7. 数据示例

概述

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）展开为线性序列：

遍历规则：

  1. 访问当前节点的第一个子项
  2. 递归访问该子项的所有子项
  3. 返回并访问当前节点的第二个子项
  4. 重复直到所有子项被访问

示例：

树形结构：
        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 的生成遵循以下规则：

  1. 子项选择：从 [0, current_meaning) 范围内随机选择子项

    • 确保子项编号小于父项，满足"编号越小越简单"的原则
    • 可以选择 token 或其他复合 meaning

  2. 子项数量：在 [min_subitem, max_subitem] 之间

    • min_subitem：最少子项数
    • max_subitem：最多子项数
    • 实际数量随机决定

  3. 递归分解：

    • 对于每个子项，如果是复合 meaning，递归获取其序列
    • 如果是 token，直接使用其值

  4. 序列拼接：

    • 按子项顺序拼接所有子序列
    • 计算每个位置的新 level、rank_idx、rank_all

  5. 层级计算：

    • 新 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 编码需要解决两个问题：

  1. 位置定位：token 在每一层中的位置是什么？
  2. 分支信息：每一层有多少个分支？

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

计算过程：

  1. 叶节点（E, F, G）：

    • 都是 token（level 0）
    • rank_idx = 0, 1, 0（各自在父节点中的位置）
    • rank_all = 0xFFFFFFF（填充值）

  2. 中间节点（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 个）

  3. 根节点（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 成为研究语言模型对结构化信息处理能力的理想工具。

No comments to display

Back to top