Kiraa

HSTU Embedding 学习笔记

Fri, 13 Feb 2026 00:00:00 +0000

Torchrec

数据结构

`JaggedTensor` (`jt`)

“Jagged” 的意思是 “锯齿状的”，顾名思义，这种 Tensor 每一行的长度不一，可以将长度差异大的特征高效存储为一个 batch，避免 padding 造成资源浪费。如，可以将不同用户的交互历史作为一个 batch，放进 JaggedTensor 中存储。

# 存储用户交互历史:
# - User 1 交互了 2 个物品
# - User 2 交互了 3 个物品
# - User 3 交互了 1 个物品

# lengths 给出每个用户交互历史的长度:
# - User 1 交互历史长度为 2
# - User 2 交互历史长度为 3
# - User 3 交互历史长度为 1
lengths = torch.tensor([2, 3, 1], dtype=torch.int32)

# offsets 给出每个用户交互历史的区间: 
# - User 1 的交互历史在 values[0:2]
# - User 2 的交互历史在 values[2:5]
# - User 3 的交互历史在 values[5:6]
offsets = torch.tensor([0, 2, 5, 6], dtype=torch.int32)  

# 实际存储的是一个一维的 Tensor，通过划分来达到变长的效果
values = torch.Tensor([101, 102, 
                       201, 202, 203, 
                       301])  

jt = JaggedTensor(lengths=lengths, values=values)
print(jt)
jt = JaggedTensor(offsets=offsets, values=values)
print(jt)

values_list = jt.to_dense() # 转为 list of tensors
print(values_list)

outputs:

JaggedTensor({
    [[101.0, 102.0], [201.0, 202.0, 203.0], [301.0]]
})

JaggedTensor({
    [[101.0, 102.0], [201.0, 202.0, 203.0], [301.0]]
})

[tensor([101., 102.]), tensor([201., 202., 203.]), tensor([301.])]

`KeyedJaggedTensor` (`kjt`)

可以理解为多个 jt 的集合，同时给每个 jt 分配了一个标签，便于区分和访问。可以用来存储不同类别的的特征。

隐含假设：不同组特征之间是一一对应的，比如一组 user_features 对应一组 item_features，会自动平均划分，所以不需要指定 lengths 或者 offsets 中的元素对应哪组特征。

keys = ["user_features", "item_features"] # 定义标签，特征包括用户特征和物品特征

# - 用户特征: 3 个用户，交互记录长度分别为 2, 0, 3
# - 物品特征: 3 个物品，特征长度分别为 1, 2, 1
lengths = torch.tensor([2, 0, 3, 1, 2, 1], dtype=torch.int32)
values = torch.Tensor([11, 12, 21, 22, 23, 101, 201, 202, 77])
# Create a KeyedJaggedTensor
kjt = KeyedJaggedTensor(keys=keys, 
                        lengths=lengths, 
                        values=values)

print(kjt)
# 通过 keys 访问不同特征
print(kjt["user_features"])
print(kjt["item_features"])

print('batch size:', kjt.stride())  # 获取批次大小

outputs:

KeyedJaggedTensor({
    "user_features": [[11.0, 12.0], [], [21.0, 22.0, 23.0]],
    "item_features": [[101.0], [201.0, 202.0], [77.0]]
})

JaggedTensor({
    [[11.0, 12.0], [], [21.0, 22.0, 23.0]]
})

JaggedTensor({
    [[101.0], [201.0, 202.0], [77.0]]
})

batch size: 3

模型

`torch.nn.Embedding`

这是 torch 中的 Embedding 层，可以用 nn.Embedding(num_embeddings, embedding_dim) 定义一个词表大小为 num_embeddings ，嵌入维度为 embedding_dim 的 Embedding 层。

# an Embedding module containing 10 tensors of size 3
embedding = nn.Embedding(10, 3) # 初始权重是随机的
# a batch of 2 samples of 4 indices each
input = torch.LongTensor([[1, 2, 4, 5], [4, 3, 2, 9]])
embedding(input)

outputs:

tensor([[[-0.0251, -1.6902,  0.7172],
         [-0.6431,  0.0748,  0.6969],
         [ 1.4970,  1.3448, -0.9685],
         [-0.3677, -2.7265, -0.1685]],

        [[ 1.4970,  1.3448, -0.9685],
         [ 0.4362, -0.4004,  0.9400],
         [-0.6431,  0.0748,  0.6969],
         [ 0.9124, -2.3616,  1.1151]]])

`EmbeddingCollection` (EC)

这个可以看作是 torch.nn.Embedding 的升级版，给每组特征搭上了标签。具体地，传入 kjt ，得到 embedding 。

e1_config = EmbeddingConfig(
    name="t1", embedding_dim=3, num_embeddings=10, feature_names=["f1"]
)
e2_config = EmbeddingConfig(
    name="t2", embedding_dim=3, num_embeddings=10, feature_names=["f2"]
)

ec = EmbeddingCollection(tables=[e1_config, e2_config])

#     0       1        2  <-- batch
# 0   [0,1] None    [2]
# 1   [3]    [4]    [5,6,7]
# ^
# feature

features = KeyedJaggedTensor.from_offsets_sync(
    keys=["f1", "f2"],
    values=torch.tensor([0, 1,                  2,    # feature 'f1'
                            3,      4,    5, 6, 7]),  # feature 'f2'
                    #    i = 1    i = 2    i = 3   <--- batch indices
    offsets=torch.tensor([
            0, 2, 2,       # 'f1' bags are values[0:2], values[2:2], and values[2:3]
            3, 4, 5, 8]),  # 'f2' bags are values[3:4], values[4:5], and values[5:8]
)

feature_embeddings = ec(features)
print(feature_embeddings)
print('------------------')
print('### f1 feature')
print(feature_embeddings["f1"].offsets())
print(feature_embeddings["f1"].values())
print('### f2 feature')
print(feature_embeddings["f2"].offsets())
print(feature_embeddings["f2"].values())

outputs:

{'f1': <torchrec.sparse.jagged_tensor.JaggedTensor object at 0x7f7eb1ab2150>, 'f2': <torchrec.sparse.jagged_tensor.JaggedTensor object at 0x7f7eb1ab1d30>}
------------------
### f1 feature
tensor([0, 2, 2, 3])
tensor([[ 0.0548,  0.1086,  0.0119],
        [ 0.0635,  0.1062, -0.2560],
        [-0.2143, -0.0599, -0.2480]])
### f2 feature
tensor([0, 1, 2, 5])
tensor([[ 0.2697,  0.1827, -0.0657],
        [-0.1316, -0.2873,  0.3116],
        [-0.0632, -0.1552, -0.0938],
        [-0.3044,  0.0939,  0.0486],
        [ 0.1156, -0.0385,  0.0146]])

`torch.nn.EmbeddingBag`

这是 Embedding + pooling 层，pooling 模式有 sum, mean, max, 默认为 mean 。传入一个 batch 后，会查表计算出每个序号的 embedding，然后进行 pooling，不会保存中间状态。

# an EmbeddingBag module containing 10 tensors of size 3
embedding_sum = nn.EmbeddingBag(10, 3, mode='sum')
# a batch of 2 samples of 4 indices each
input = torch.tensor([1, 2, 4, 5, 4, 3, 2, 9], dtype=torch.long)
offsets = torch.tensor([0, 4,], dtype=torch.long)
print(embedding_sum(input, offsets))

input = torch.tensor([[1, 2, 4, 5], [4, 3, 2, 9]], dtype=torch.long)
print(embedding_sum(input))

outputs:

tensor([[-0.8861, -5.4350, -0.0523],
        [ 1.1306, -2.5798, -1.0044]])
tensor([[-0.8861, -5.4350, -0.0523],
        [ 1.1306, -2.5798, -1.0044]])

这里支持 offsets 参数，使用起始位置来划分每个 batch。所以可以传入 2D 的 inputs ，也可以传入 1D 的 inputs + offsets 。

`EmbeddingBagCollection` (`EBC`)

这个可以看作是 torch.nn.EmbeddingBag 的升级版。可以根据 featrue_names 对特征进行池化。具体地，传入 kjt ，前向传播得到池化后的特征。

table_0 = EmbeddingBagConfig(
    name="t1", embedding_dim=3, num_embeddings=10, feature_names=["f1"]
)
table_1 = EmbeddingBagConfig(
    name="t2", embedding_dim=4, num_embeddings=10, feature_names=["f2"]
)

ebc = EmbeddingBagCollection(tables=[table_0, table_1])

#        i = 0     i = 1    i = 2  <-- batch indices
# "f1"   [0,1]     None      [2]
# "f2"   [3]       [4]     [5,6,7]
#  ^
# features

features = KeyedJaggedTensor(
    keys=["f1", "f2"],
    values=torch.tensor([0, 1,                  2,    # feature 'f1'
                            3,      4,    5, 6, 7]),  # feature 'f2'
                    #    i = 1    i = 2    i = 3   <--- batch indices
    offsets=torch.tensor([
            0, 2, 2,       # 'f1' bags are values[0:2], values[2:2], and values[2:3]
            3, 4, 5, 8]),  # 'f2' bags are values[3:4], values[4:5], and values[5:8]
)

pooled_embeddings = ebc(features)
print(pooled_embeddings)
print(pooled_embeddings.values())
print(pooled_embeddings.keys())
print(pooled_embeddings.offset_per_key())

outputs:

KeyedTensor({
    "f1": [[-0.05368266999721527, -0.49714457988739014, 0.027471214532852173], [0.0, 0.0, 0.0], [-0.09605476260185242, -0.30402711033821106, -0.013938307762145996]],
    "f2": [[-0.20428268611431122, -0.25504255294799805, 0.23750828206539154, 0.3035320043563843], [0.057708702981472015, 0.14746926724910736, 0.05408177152276039, -0.2895013391971588], [-0.010172609239816666, -0.01704445481300354, -0.07303650677204132, 0.3184009790420532]]
})

tensor([[-0.0537, -0.4971,  0.0275, -0.2043, -0.2550,  0.2375,  0.3035],
        [ 0.0000,  0.0000,  0.0000,  0.0577,  0.1475,  0.0541, -0.2895],
        [-0.0961, -0.3040, -0.0139, -0.0102, -0.0170, -0.0730,  0.3184]],
       grad_fn=<CatBackward0>)
['f1', 'f2']
[0, 3, 7]

HSTU Embedding

OneRev V2 学习笔记

Fri, 06 Feb 2026 00:00:00 +0000

OneRec V2

Kuaishou OneRec Family

版本	论文/报告标题	发布时间 (arXiv)	核心架构	解决的关键痛点
OneRec V1	OneRec Technical Report	2025. 06	Encoder-Decoder	范式验证：证明了“推荐”可以重构为“生成”任务。
OneRec V2	OneRec-V2 Technical Report	2025. 08	Lazy Decoder-Only	计算效率：解决 V1 编码太慢的问题，实现工业级低延迟。
OneRec-Think	OneRec-Think: In-Text Reasoning for Generative Recommendation	2025. 10	Think-Ahead (CoT)	深度理解：让模型在推荐前先“思考”理由，增强可解释性。
OpenOneRec	OpenOneRec Technical Report	2025. 12	Qwen-based	开源与通用：打破数据孤岛，发布基础模型。

分为两组：

**OneRec V1/V2: ** 主攻端到端，低延时，在线推荐，V2 是对 V1 的改进。

OpenRec V2 改进了 V1 的 encoder-decoder 结构，总计算量（应该指推理的 FLOPS）减少 94%，训练资源减少 90%。模型参数可以从 0.5B 扩展到 8B，同时符合 scaling law。
**OneRec-Think / OpenOneRec ** 主攻逻辑推理、语义理解，让模型不仅知道推荐什么，还知道为什么推荐。前者在业务上有实际的部署和验证；后者则完全基于 Qwen，倾向于在学术界给出一个通用的范式。

以下主要介绍 OneRec V2 的模型结构和推理过程。

Tokenizer

这一步和 OneRec V1 相同。目的是给每个 video 赋予一个 token，用低维特征表示高维稀疏特征。

相似物品数据集构建

我们希望构造一个数据集 $D$ ，里面包含若干个物品对，表示这些物品之间是相似的。

考虑用现有模型或方法从两方面提取：

User2Item: 当用户点击了 $A$ ，并且是正向的，那么从用户最近点击的 50 个正向物品中，选一个与 $A$ 最相似的物品 $B$ ，构造相似物品对 $(A, B)$ 加入 $D$ 中。
Item2Item: 使用现有方法（如 Swing retrieval model），可以直接提取出若干相似物品对加入 $D$ 。

对比学习

对于每个 video，提取以下特征：

视频封面 + 5 帧图像
标题 + Tag + 图像转文字 (OCR) + 语音转文字 (ASR)

将特征输入 miniCPM-V-8B ，得到 1280 个 512 维的特征向量：

\mathbf{M} \in \mathbb{R} ^ {N_M \times d_t} \\ N_M = 1280, d_t = 512

然后使用交叉注意力机制压缩信息。具体地：

\mathbf{Q}^{(i+1)} = \text{CrossAttn}(\mathbf{Q}^{(i)}, \mathbf{M}, \mathbf{M})\\ \mathbf{Q}^{(i+1)} = \text{FFN}(\text{RMSNorm}(\mathbf{Q}^{(i+1)})),\quad \text{for}\ i = 1 \to N_c

其中 $\mathbf{Q} \in \mathbf{R}^{N_{M'}\times d_t}$ 。 $\mathbf{M}$ 最后压缩成了 $N_c$ 个 $d_t$ 维的特征向量：

\mathbf{M'} = \mathbf{Q}^{(Nc+1)} \in \mathbb{R} ^ {N_c \times d_t}

$\text{CrossAttn}(\mathbf{Q}, \mathbf{K}, \mathbf{V})$ 表示对应位置上的矩阵做 Attention 计算，只不过三个矩阵不一定来自同一个序列，所以称为 Cross 。

注意到前一层计算的结果直接作为下一层的 $\mathbf{Q}$ ，所以只需确定 $\mathbf{Q}^{(1)}$ 和各个 $\text{FFN}$ 的参数即可。

论文中取 $N_{M'} = 4, N_c =4$ ，表示最后得到 $4$ 个特征向量，模型包含 $4$ 个 Transformer 层。

最后对提取出来的向量计算对比损失。同时还加了一个 LLaMA3 对特征向量解码，与 video 标题做对比，也算入损失中，让特征保持语义，推理的时候无需 LLaMA3 这一步。

RQ-Code

对提取出来的特征，每次进行 K-means 聚类，然后特征减去聚类中心（共 8192 个），依次迭代，共 3 层。将聚类中心编码作为码表，得到 8192x8192x8192 的三位编号，作为 video 的语义 token ，实现了用低维表示高维稀疏特征。

Multi-Scale Feature Engineering

这一步和 OneRec V1 相同。

User Static Pathway

用户个人数据特征：uid，年龄，性别等统一到 64 维特征向量，拼接后塞进 MLP 。

\begin{aligned} \mathbf{f}_u &= [\mathbf{e}_{\text{uid}}; \mathbf{e}_{\text{gender}}; \mathbf{e}_{\text{age}}; \cdots]\\ \mathbf{h}_u &= \text{Dense}(\text{LeakyReLU}(\text{Dense}(\mathbf{f}_u)))\\ \end{aligned}

其中，

\mathbf{e}_{\text{uid}}, \mathbf{e}_{\text{gender}}, \mathbf{e}_{\text{age}} \in \mathbb{R}^{64}\\\mathbf{h}_u \in \mathbb{R}^{1 \times d_{\text{model}}}

Short-term Pathway

提取用户最近的 $L_s = 20$ 条交互数据，包含视频编号、作者、tag、交互行为等等，总之是拼在一起然后塞进 MLP，得到 $L_s$ 个 $d_{\text{mode}l}$ 维的特征 $\mathbf{h}_s \in \mathbb{R}^{L_s \times d_{\text{model}}}$ ，这里不再赘述。

Positive-feedback PathWay

提取用户最近的 $L_p = 256$ 条 high-engagement 交互数据，类似的方式得到 $\mathbf{h}_p \in \mathbb{R}^{L_p \times d_{\text{model}}}$ 。

Lifelong Pathway

这个有点复杂，总之得到了 $\mathbf{h}_l \in \mathbb{R}^{N_q \times d_{\text{model}}}$ ，其中 $N_q = 128$ 。

总结

对于每个用户，从四个方面得到了 $1 + L_s + L_p + N_q$ 个特征向量。

Context Processor

这一步与 V1 不同，V1 使用一个 Encoder 来处理特征向量，这里换成了更轻量的 Context Processor，优化了繁琐的 Encode 计算。

Lazy Decoder Block

适配

首先，

vLLM 学习笔记

Mon, 02 Feb 2026 00:00:00 +0000

什么是 vLLM

vLLM, virtual Large Language Model, 是一个高性能、低延迟的大模型推理和部署库。目的是加速模型推理，并节省显存。其核心创新是 PagedAttention 机制。

之前总是把模型的训练和推理混为一谈，但实际上区别还是有的。虽然两者都要进行前向传播计算，但是训练还要反向传播，而推理则更加纯粹。此外，推理面对的是更具体的落地应用场景，有高并发、大批量等需求，因此优化推理过程意义很大。

LLM 推理回顾：KV Cache 引入

要优化推理，首先要知道推理的过程是怎么样的。

众所周知当下主流 LLM 都是 自回归 的，即：将 prompt 作为输入，预测下一个词，然后拼接预测结果到 prompt 末尾，作为新的 prompt，继续预测下一个词，直到输出结束标志为止。

我们可以将这个过程分为两个部分：Prefill 和 Decoding。

Prefill

在这一阶段，用户给出一个完整的 $\text{prompt} = \{x_1, x_2, \ldots, x_n\}$ ，模型需要对这个 prompt 进行前向传播计算，预测下一个词 $x_{n+1}$ 。

这一部分其实和训练时的前向传播是一样的，只不过不需要计算 loss 和进行反向传播。下图是一个具有 $m$ 个 Transformer 层的模型的前向传播示意图：

LLM 结构

这里，Input Tokens 是 ${x_1, x_2, \ldots, x_n}$ ，Output Tokens 是 ${x'_2, x'_3, \ldots, x'_{n+1}}$ 。在训练的时候，我们会计算 Output Tokens 和真实的 ${x_2, x_3, \ldots, x_{n+1}}$ 之间的 loss。但是在推理时，我们只需要取最后一个输出 $x'_{n+1}$ 作为预测结果。

既然 $n$ 个 output token 中，我们只需要一个，有没有办法优化呢。其实是可以略微优化一点点。只需要最后一个 output token，说明我们只需要最后一层隐藏状态中的 $\text{HiddenState}_{m, n}$ ，于是我们的 $Q_m = [q_{m, 1}, q_{m, 2}, \cdots, q_{m, n}] ^ T$ 只用保留 $q_{m, n}$ 这一个向量就可以了，但是除此之外 $K_m,\ V_m$ 还是需要全部保留。又由于 $K_m$ 和 $V_m$ 依赖于该层输入的所有隐藏状态，因此我们还是需要保留所有层的所有隐藏状态和相应的 $Q,K, V$ 。

那么，这一阶段的前向传播要点就是，除了最后一层 Transformer 的 $Q$ 可以简化之外，前面所有层都要完整地计算 $QK^TV$ 并得到所有隐藏状态。但实际上很多时候，这样的小优化意义不大，因此我们可以将其视为所有层都完整地计算了 $QK^TV$ 和对应的隐藏状态。

Decoding

在这一阶段，模型开始进行自回归生成，即每次把上一步预测的词拼接到 prompt 末尾，作为新的输入，继续预测下一个词。这个过程会持续多次，直到生成结束标志为止。

假如现在我预测 $x'_{n+1}$ ，那么同样地，我们可以从末尾先追踪回去，看看需要哪些隐藏状态和 $Q, K, V$ 。事实上，我们发现关键是每一层的隐藏状态要出来。既然我们之前已经把前面 token 的每一层隐藏状态都算过了，那么只需补齐 $x_n$ 在每一层的隐藏状态。这样，在每一层的 Transformer 中，我们都只需用到一个 $q$ 向量来参与计算。进一步地，既然保存隐藏状态是为了计算 $K$ 和 $V$ ，那么我们直接一步到位，把 $K$ 和 $V$ 给保存下来就行了。

到这里已经比较清晰，我们可以通过缓存每一层 Transformer 的 $K$ 和 $V$ 方式来避免重复计算。推理时，在每一层计算当前 token 对应的 $q$ ，然后和缓存的 $K$ 和 $V$ 做注意力计算，得到当前层的输出即可。

这种缓存机制则被称为 KV Cache 。KV Cache 用显存换取了计算速度，大大加速了自回归生成的过程。

PagedAttention：解决显存分配问题

KV Cache 带来的显存分配问题

虽然我们通过 KV Cache 加速了推理过程，但是也带来了显存分配的问题。这是因为 KV Cache 是动态的，随着生成的进行，缓存的 $K$ 和 $V$ 会不断增长；KV Cache 也是未知的，我们无法预知最终会生成多少 token。在 vLLM 之前，大多数推理框架的策略都是按照 max_token 来预分配一段连续的显存空间给每一个推理请求，但这无疑会造成显存碎片化和显存浪费等问题。

显存使用情况对比 (来源: vLLM 论文 https://arxiv.org/abs/2309.06180)

如上图所示，Token states 表示实际使用的显存；Reservation 表示预分配且实际使用的显存；Interal Frag. 表示预分配但未使用的显存；External Frag. 表示未使用且未预分配的显存，可以理解为连续显存之间的空隙。传统方法显存利用率极低，而 vLLM 利用率则高得多。

vLLM 之所以能有效地解决显存分配问题，关键在于其提出的 PagedAttention 机制。

PagedAttention 机制

Med3DVLM 模型架构及训练流程详解

Fri, 30 Jan 2026 00:00:00 +0000

Med3DVLM 是一种专为医学影像诊断设计的多模态大模型，结合了先进的图像和文本处理技术，实现了对医学影像与相关文本信息的深度理解和关联。本文将详细介绍 Med3DVLM 的模型架构及其训练流程。

参考：mirthAI/Med3DVLM

训练阶段一：图文对比学习

这一阶段主要训练 Vision-Encoder 。

Vision-Encoder 图像编码器: DCFormer

DecompConv3D 分解 3D 卷积

如图，传统的 3D 卷积块的参数量为 $K \times K \times K$ ，可以在三个方向上进行分解，分别为 $K \times 1 \times 1$ 、 $1 \times K \times 1$ 和 $1 \times 1 \times K$ ，只保留三维中的“骨架”，参数减少为 $3 \times K$ 。（ $K$ 为奇数）

实际使用时，可以在图像的对应维度周围填充 $\lfloor\dfrac{K}{2}\rfloor$ 个像素，以保持输入输出尺寸一致。

注意：图中的中心位置实际上有 3 个参数，分别对应三个方向的卷积核。

（图片为 AI 生成，有部分奇怪的地方，请见谅）

DecomposedStem 分解卷积 Stem 模块

网络中的 Stem 模块一般指模型的初始层，Stem 有“茎”的意思，表示模型的起点

假设输入数据为 (B, C_in, H, W, D) 。

B：批次大小 (Batch Size)
C_in：输入通道数 (Input Channels)
H, W, D：输入数据的高度、宽度和深度

步骤	参数	维度	备注
初始	/	`(B, C_in, H, W, D)`	输入数据
DecompConv3D	`kernel_size=7, stride=4`	`(B, C_out, H/4, W/4, D/4)`	下采样到 1/4 大小，通道数变为 `C_out`
DecompConv3D	`kernel_size=3, stride=1`	`(B, C_out, H/4, W/4, D/4)`	保持尺寸不变，加深网络
DecompConv3D	`kernel_size=3, stride=1`	`(B, C_out, H/4, W/4, D/4)`	保持尺寸不变，加深网络
DecompConv3D	`kernel_size=3, stride=1`	`(B, C_out, H/4, W/4, D/4)`	保持尺寸不变，加深网络

总结：(B, C_in, H, W, D) -> (B, C_out, H/4, W/4, D/4) 。

 return nn.Sequential(
        # 初始步长为 4 ，下采样到 1/4，(H, W, D) -> (H/4, W/4, D/4)
        DecompConv3D(inp, oup, kernel_size=7, stride=4, groups=1, act=nn.GELU()),
        # 后三步长为 1，不进行下采样
        DecompConv3D(oup, oup, kernel_size=3, stride=1, groups=1, act=nn.GELU()),
        DecompConv3D(oup, oup, kernel_size=3, stride=1, groups=1, act=nn.GELU()),
        DecompConv3D(oup, oup, kernel_size=3, stride=1, groups=1, act=nn.GELU()),
    )

ConvBlock 卷积块

每次分解卷积后，通道特征进入单隐藏层的 MLP，之后经过学习的缩放参数，最后通过残差连接与输入相加，形成卷积块的输出。

一般是多个 ConvBlock 叠起来用，在使用之前要先进行下采样和通道数调整。

1. 下采样 & 通道数调整

输入特征：(B, C_in, H, W, D) 。

步骤	参数	维度	备注
初始	/	`(B, C_in, H, W, D)`	输入数据
`MaxPool3d`(非分解卷积)	`kernel_size=3, stride=2`	`(B, C_in, H/2, W/2, D/2)`	下采样到 1/2 大小，通道数不变
`Conv3d`(非分解卷积)	`kernel_size=1, stride=1`	`(B, C_out, H/2, W/2, D/2)`	调整通道数到 `C_out`，尺寸不变

2. 经过 ConvBlock

以下是单个 ConvBlock 的计算过程，输入数据维度为 (B, C_out, H/2, W/2, D/2) 。

步骤	参数	维度	备注
初始	/	`(B, C_out, H/2, W/2, D/2)`	输入数据（上一步输出）
DecompConv3D	`stride=1`	`(B, C_out, H/2, W/2, D/2)`	保持尺寸不变
变换形状	/	`(B, H/2, W/2, D/2, C_out)`	将通道数移到最后
MLP	`hidden_dim=4*C_out`	`(B, H/2, W/2, D/2, C_out)`	融合通道特征
缩放	/	`(B, H/2, W/2, D/2, C_out)`	通道特征乘上一个长度为 `C_out` 的可学习参数
变换形状	/	`(B, C_out, H/2, W/2, D/2)`	将通道数移回前面
残差连接	/	`(B, C_out, H/2, W/2, D/2)`	与经过 MLP 前的输入相加

然后，将上述 ConvBlock 再重复多次，得到最终输出。

DCFormer 总体架构

以代码中的 decomp_small 为例，整体架构如下：

def decomp_small(
    input_size=(512, 512, 256),
):

    model = DecompModel(
        input_size=input_size,
        num_blocks=[1, 2, 3, 6, 2],
        channels=[64, 96, 192, 384, 768],
    )
    return model

其中包含 5 个阶段，其中第一个阶段是单个 DecomposedStem 模块，后面四个阶段是 ConvBlock 模块堆叠而成。

num_blocks=[1, 2, 3, 6, 2] ：表示每个阶段堆叠的卷积块数量。
channels=[64, 96, 192, 384, 768] : 表示每个阶段的输出通道数。

流程图如下（从上到下，从左到右）：

最后得到了 (B, 256, 768) 的图像特征向量，表示 256 个 token，每个 token 的维度为 768。

这个可以理解为，每个 token 对应图像中的一个局部区域，包含该区域的视觉信息。

Text-Encoder 文本编码器: BERT

BERT 是一种基于 Transformer 的预训练语言模型，能够有效地捕捉文本中的语义信息。

BERT 的输出包括两部分：

(B, L, D) ：每个 token 的特征向量，L 为序列长度，D 为隐藏层维度 (embedding 维度)。
(B, D) ：[CLS] token 的特征向量，通常用于句子级别的表示，可以看作是整个文本的摘要。

Loss Function 损失函数: SigLIP

Vision-Encoder 输出的是图像特征向量 (B, L, D1) ，通过平均池化得到图像的全局特征向量 (B, D1) 。
Text-Encoder 输出的是文本的 [CLS] 特征向量 (B, D2) 。
两者都要再进入一个线性变换层，映射到相同的维度空间 (B, D) 。
然后两者进行归一化处理，得到单位向量，只保留方向信息。
目标：让匹配的图像-文本对在向量空间中尽可能重合，而不匹配的对尽可能远离。这一点反映到点积运算上，就是让匹配对的特征向量点积尽可能大，而不匹配对的点积尽可能小。

设图像特征为 $F_{img} \in \mathbb{R}^{B \times D}$ ，文本特征为 $F_{text} \in \mathbb{R}^{B \times D}$ 。

相乘得到相似度矩阵 $S \in \mathbb{R}^{B \times B}$ ：

S = F_{img} \cdot F_{text}^T

这样， $S(i, j)$ 表示第 $i$ 个图像与第 $j$ 个文本的相似度。

假设当且仅当 $i = j$ 时，图像和文本是匹配的。我们可以构造标签矩阵 $L \in \mathbb{R}^{B \times B}$ ：

L = 2I - E = \begin{bmatrix} 1 & -1 & -1 & \cdots & -1 \\ -1 & 1 & -1 & \cdots & -1 \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ -1 & -1 & -1 & \cdots & 1 \end{bmatrix}

即正样本是 1，负样本是 -1。

计算损失函数：

Loss = - \sum_{i=1}^{B} \sum_{j=1}^{B} \log \sigma ( S(i, j) \cdot L(i, j) )

相比于 normalized cross-entropy (NCE) 损失，SigLIP 损失对小 batch size 不敏感。

训练

解冻 Vision-Encoder 和 Text-Encoder 的所有参数，使用上述的对比损失函数进行训练。

数据集：M3D-Cap，包括 3D CT 扫描和对应的报告。所有 3D 体积缩放为 $128 \times 256 \times 256$ 。

参数：

batch $64$ , 学习率 $10^{-4}$ ，权重衰减 $0.1$ ，训练 $100$ epochs .
AdamW, warmup ratio = 0.03
cosine learning rates cheduler

训练阶段二：VLM-Pretraining

这一阶段主要训练图像模态到文字模态的投影层。

Multi-Scale MLP-Mixer 多层次MLP混合器

Mixer Layer 特征混合块 (空间 + 通道)

假设 DCFormer 最后输出了特征 (B, 32, 768) ，这可以理解为有 32 个 token，每个 token 代表了原图一个局部区域的特征，每个 token 的 embedding 维度即通道数量是 768 。

首先，进行空间特征混合，转置特征得到 (B, 768, 32) ，然后通过全连接层映射到 (B, 768, 64) ，经过激活函数 GELU，再通过全连接层，但不改变通道数，这样就完成了空间特征混合。这一部分 “全连接层-GELU-全连接层” 的结构是一个 MLP，即为上图中间部分。

然后，转置回 (B, 64, 768) ，进行通道特征混合，类似地，通过 MLP 映射到 (B, 64, 1792) 。

这样，就完成了一次 (B, 32, 768) -> (B, 64, 1792) 的转换，这个转换所在的结构被称为 Mixer Layer。论文中用了两个 Mixer Layer 叠起来，实现了 (B, 32, 768) -> (B, 64, 1792) -> (B, 128, 3584) 的转换，充分混合了空间和通道特征，这应该是一个上采样 Decoder 的结构。其中，128 表示空间特征，他们已经充分混合，很难说每一维代表了哪部分图像，但是可以作为图像总体的表示。3584 表示通道特征，为什么是这个数字呢？因为 Qwen2.5-7B 的 Embedding 维度就是 3584 ，这样就可以和 LLM 的输入对齐了。

所以，最终得到 (B, 128, 3584) 可以看作是用 128 个 token 描述了 DCFormer 的深层特征 (B, 32, 768) 。

高低层特征混合

DCFormer 的倒数第二层特征为 (B, 256, 384) ，我们称为低层特征 (low features) ，与之相对的，上面提到的最后一层特征 (B, 32, 768) ，我们称为高层特征 (high features)。

对 low features 和 high features 分别输入 Mixer Layer，可以得到两个 (B, 128, 3584) 的特征，将他们拼接在一起得到 (B, 256, 3584) ，这就是我们最终得到的描述图像的特征。

这个高底层特征混合的思路被作者认为是他们论文的核心创新点。

Qwen2.5-7B 适配

在 llm 的词表中插入一个特殊 token <im_patch> 表示图片 token 的占位符。

这样一段数据就变成：

"<im_patch><im_patch><im_patch><im_patch><im_patch>A well-defined hypodense mass lesion is seen within the gastric antrum. It is of fatty attenuation value and does not show enhancement in the post-contrast series“

理论上来说应该有 256 个 <im_patch> ，与上文中 256 个图片 token 一一对应。

训练的时候，在 embedding 之后把占位符 <im_patch> 换成图片 token 即可。

我们做实验的时候应该需要换成新版的 Qwen3，否则落后了。

训练

冻结 Vision Encoder 的所有参数，解冻投影层所有参数，只解冻 LLM 的 Embedding 参数，其余全部冻结。

数据集：M3D-Cap 和 M3D-VQA (yes/no 问答除外)，图片为 3D 扫描，问题是自然语言询问，回答是自由格式的文本。

参数：batchsize $16$ , 学习率 $10^{-4}$ , 无学习率衰减, $3$ epochs .

直接使用 transformers 的 LLM 训练器即可，原理大概为：

原始数据："图片左上方有肿瘤。"
喂给模型 "图"，让其预测 "片"的概率，计算损失。
喂给模型 "图片"，让其预测 "左" 的概率，计算损失。
喂给模型 "图片左"，让其预测 "上" 的概率，计算损失。
以此类推……

训练阶段三：VLM Fine-Tuning

LoRA 微调

原理如下：

对于一个线性的环节，前向传播可以这样表示（假设已结合偏置项）：

Y = XW

其中 $X$ 是输入特征， $W$ 是权重矩阵， $Y$ 是输出特征。

假设 $W\in \mathbb{R}^{d \times k}$ ，参数量为 $d \times k$ ，调节所有参数奢侈的。因此，我们引入两个较小的矩阵 $A \in \mathbb{R}^{d \times r}$ 和 $B \in \mathbb{R}^{r \times k}$ ，其中 $r << min(d, k)$ 。新的权重矩阵表示为：

W' = W + \Delta W = W + AB

这样，我们只需要学习 $A$ 和 $B$ 的参数，参数量变为 $d \times r + r \times k$ ，大大减少了需要调节的参数数量。这就是 LoRA 的核心思想。

我们可以对 LLM 中的所有线性环节都应用 LoRA，从而达到微调整个模型的目的。

实际应用中公式为：

W' = W + \dfrac{\alpha}{r} AB

其中 $\alpha$ 是一个缩放系数。

训练

冻结 Vision Encoder ，解冻投影层和 LLM 的 LoRA 参数，解冻 LLM 的 embedding 参数和输出层参数。

数据集：M3D-Cap 和 M3D-VQA 。

参数：

LoRA: Rank = 16, $\alpha$ = 32, Dropout = 0.1
batchsize $8$ , 学习率 $5 \times 10^{-5}$ , 无权重衰减, 训练 $5$ epochs .

qwen3-0.6B 学习笔记

Fri, 30 Jan 2026 00:00:00 +0000

0 Qwen3 Technical Report

原文: Qwen3 Technical Report

Qwen3 稠密模型与 Qwen2.5 相似，共同特点是：

分组查询头 (Grouped Query Attention, GQA) ，即多个 Q-head 共享同一组 KV 。
SwiGLU，替代了传统 transformer 中简单的 MLP 。
旋转位置编码 (Rotary Positional Embeddings, ROPE) ，用于对 Q-head 和 K-head 注入位置信息。
RMSNorm，均方根归一化。
pre-norm，主要是针对残差连接的。数据输入后，先归一化，再进入模块计算，最后加上原始输入。与之相对的是 post-norm，表示数据输入后，先进入模块计算，再加上原始输入，最后统一归一化。pre-norm 可以避免训练时梯度消失。

不同点：

溢出了 QKV-bias 。
引入了 QK-Norm 。

主要参数：

Models	Layers	Heads(Q / KV)	Tie Embedding	Context Length
Qwen3-0.6B	28	16 / 8	Yes	32K

其中 Tie Embedding 表示 Embedding 和解 Embedding 共享权重。

1 打印模型结构

可以使用 modelscope 上面的模型，无须代理或镜像，速度较快。需要按照 modelscope 和 transformers 库。

运行以下代码可得到模型的基本配置：

from modelscope import AutoConfig, AutoModelForCausalLM
config = AutoConfig.from_pretrained("Qwen/Qwen3-0.6B")
print(config)

输出为：

Qwen3Config {
  "architectures": [
    "Qwen3ForCausalLM"          # 因果语言模型
  ],
  "attention_bias": false,      # 无注意力偏置
  "attention_dropout": 0.0,
  "bos_token_id": 151643,       # 特殊 token: 句子开始标记
  "dtype": "bfloat16",          
  "eos_token_id": 151645,       # 特殊 token: 句子结束标记
  "head_dim": 128,              # 注意力头维度
  "hidden_act": "silu",         # 激活函数
  "hidden_size": 1024,          # 隐藏层大小
  "initializer_range": 0.02,    
  "intermediate_size": 3072,    # MLP 中间层大小, 3072 = 3 * 1024
  "layer_types": [              # 每层的类型, 全部为 'full_attention', 一共 28 层
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention",
    "full_attention"
  ],
  "max_position_embeddings": 40960, # 最大上下文长度
  "max_window_layers": 28,          
  "model_type": "qwen3",
  "num_attention_heads": 16,        # 注意力头数量
  "num_hidden_layers": 28,          # 隐藏层数量
  "num_key_value_heads": 8,         # K, V 注意力头数量
  "pad_token_id": null,
  "rms_norm_eps": 1e-06,            # RMS 归一化的 epsilon 值
  "rope_parameters": {
    "rope_theta": 1000000,
    "rope_type": "default"
  },
  "sliding_window": null,
  "tie_word_embeddings": true,      # 词嵌入共享
  "transformers_version": "5.0.0",
  "use_cache": true,
  "use_sliding_window": false,
  "vocab_size": 151936              # 词表大小
}

看懂该 config，需要对 LLM 的主流结构有一定了解，而事实上他们是大同小异的，可参考：Transformer Explainer: LLM Transformer Model Visually Explained

关注点：

"head_dim": 128 表示注意力头的维度。
"hidden_size": 1024 表示隐藏状态大小，即 embedding 的维度。
"num_attention_heads": 16, "num_key_value_heads": 8 一共有 16 组注意力头，但是 KV 头只有 8 组，说明使用了分组注意力，16 个 Q-head 共享 8 组 KV 。
intermediate_size": 3072 表示 MLP 中间隐藏层的维度，其中正好是 hidden_size 的 3 倍。事实上，该值之前一般取 4 倍 hidden_size ，但是由于 SwiGLU 的参数是朴素的 MLP 的 1.5 倍，将 intermediate_size 调小有助于平衡参数量。
"num_hidden_layers": 28 表示隐藏层的数量，这里指的是中间 Transformer 模块的堆叠的数量。
"tie_word_embeddings": true 表示 embedding 和解 embedding 共享权重。
"vocab_size": 151936 词表大小为 151936 .

进一步的，可以打印第一个 block 来查看结构：

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    torch_dtype="auto",
    device_map="auto"
)
first_layer = model.model.layers[0]
print(first_layer)

输出为：

Qwen3DecoderLayer(
  (self_attn): Qwen3Attention( # Attention 模块
    # q-head: 16 * 头维度 128 = 2048
    (q_proj): Linear(in_features=1024, out_features=2048, bias=False) 
	# k-head: 8  * 头维度 128 = 1024
    (k_proj): Linear(in_features=1024, out_features=1024, bias=False) 
	# v-head: 8  * 头维度 128 = 1024
    (v_proj): Linear(in_features=1024, out_features=1024, bias=False) 
	# Q(K^T)V 算出来隐藏层维度为 2048，需要转换回 embedding 的 1024 维
    (o_proj): Linear(in_features=2048, out_features=1024, bias=False) 
    (q_norm): Qwen3RMSNorm((128,), eps=1e-06) // 新引入的 q_norm
    (k_norm): Qwen3RMSNorm((128,), eps=1e-06) // 新引入的 k_norm
  )
  (mlp): Qwen3MLP( # MLP 模块, SwiGLU
    (gate_proj): Linear(in_features=1024, out_features=3072, bias=False)
    (up_proj): Linear(in_features=1024, out_features=3072, bias=False)
    (down_proj): Linear(in_features=3072, out_features=1024, bias=False)
    (act_fn): SiLUActivation()
  )
  (input_layernorm): Qwen3RMSNorm((1024,), eps=1e-06)
  (post_attention_layernorm): Qwen3RMSNorm((1024,), eps=1e-06)
)

这里很清晰了，到 transfomers 库里面找相应 class 的源码可以进一步了解，不再赘述。

2 模型结构整理

模型结构整理如下：

Qwen3-0.6B 模型结构

OpenOneRec 论文阅读笔记

Wed, 28 Jan 2026 00:00:00 +0000

0

原文：OpenOneRec Technical Report

尽管 OneRec 系列已将散乱的推荐算法 pipeline 统一成了一个 end-to-end 的推荐系统框架。但是推荐系统和生成式智能之间仍然有 a huge gap: Isolated Data (孤立数据).
Isolated Data 可以理解为推荐系统和生成式智能在数据使用上的差异。推荐系统中的数据，如用户行为数据、物品属性数据等，这些数据往往是结构化的、离散的，并且与具体的推荐任务紧密相关，重要的是缺乏相关的语义信息。同时也可以指不同平台之间的数据隔离。
而生成式智能（如大语言模型）则主要依赖于海量的文本数据，这些数据通常是非结构化的，包含丰富的语义信息，能够捕捉到语言的复杂性和多样性。
因此推荐系统的模型虽然能够在特定任务上表现出色，但往往缺乏世界知识、语义理解和推理能力，难以生成高质量的内容，限制了模型的泛化能力和适应性。
此外 OneRec Team 还认为，这个 gap 的产生也是因为缺乏一个统一的 benchmark 来评估和比较推荐系统在生成式智能任务上的表现，从而阻碍了该领域的研究和发展。
为了弥合这个 gap，OneRec Team 的贡献如下：
1. RecIF-Bench & OpenData: 一个统一的 benchmark，覆盖 8 种任务，用来衡量从基础推荐到复杂推理的能力。
2. Framework & Scaling: 开源了 OpenOneRec 框架，并且展示了生成式推荐系统在大规模训练下的潜力。
3. SOTA Results: 在多个任务上达到了 SOTA 结果，展示了生成式推荐系统的强大能力。

1 Items as Tokens

1.1 Itemic Tokens

推荐系统的一个基本挑战是：离散物品特征 (items) 与连续文本特征 (tokens) 之间的失配。

朴素的想法是：使用长文本描述来替代 items，但存在两个问题：
1. 上下文过长
2. 可能会生成不存在的 items
OneRec Team 的想法是：将 items 视作一种特殊的 token：Itemic Tokens ，其特点是：
1. 长度短 (short): 确保模型在长上下文上的效率。
2. 长度固定 (fixed-length sequences): 保持 token-item 的协作结构固定。
3. 分层离散代码 (hierarchical discrete codes): 确保语义相近的 items 拥有相同的前缀，让模型易于理解。

1.2 计算方法: Residual-Quantized Code, RQ Code

参考文章：QARM: Quantitative Alignment Multi-Modal Recommendation at Kuaishou

对比学习

我们希望构造一个数据集 $D$ ，里面包含若干个物品对，表示这些物品之间是相似的。
可以用现有模型或方法从两方面提取
- User2Item: 当用户点击了 $A$ ，并且是正向的，那么从用户最近点击的 50 个正向物品中，选一个与 $A$ 最相似的物品 $B$ ，构造相似物品对 $(A, B)$ 加入 $D$ 中。
- Item2Item: 使用现有方法（如 Swing retrieval model），可以直接提取出若干相似物品对加入 $D$ 。
这样，对于一个 Batch 的物品，我们就可以用对比学习的方式训练一个编码器，将物品 id 嵌入（embed）到高维空间中。

RQ Code

现在对于一个物品，我们存在一个 id 到高维向量的映射，但是直接拿这个高维向量当作 token 还是不好，因为稀疏、噪声大等问题？总之推荐模型更适配离散 id 风格的特征。
所以我们假设现在的特征为 $X\in \mathbb{R}^{N\times D}$ ，表示有 $N$ 个物品，每个物品 $D$ 维的特征。
首先设定一超参数 $L$ 。选择 $L$ 个聚类中心进行 K-means 聚类。
聚类完成后，每个物品选择离他最近的聚类中心的编号作为第一层编号。
接着，每个物品减去第一层聚类中心，得到残差。然后对残差进行第二层 K-means 聚类，得到第二层编号。
重复上述过程 $L$ 层，最终每个物品会得到 $L$ 个编号，组成一个长度为 $L$ 的序列，作为该物品的 RQ Code。
RQ Code 可以理解为前几层负责捕捉物品的全局语义，后几层负责捕捉细节。

2 推荐系统的自回归模型

当 items 对齐到 token 空间之后，我们的词表变为 $V = V_{text} \cup V_{item}$ 。这样我们可以将用户的交互历史直接视作一个长文本序列，而非特殊的结构化数据，从而可以使用自回归的方式解决问题。

指令 (Instruction) : $I$
用户历史 (User History) : $C$
最小化以下损失函数：
$L(\theta) = -\sum_{t=1}^{|Y|} \log P_\theta(y_t | I, C, y_{<t})$
其中 $Y$ 是目标推荐序列或者自然语言文本，这取决于具体任务。
该模式让我们得以利用现有的强大语言模型 (LLM) 来处理任务。

3 RecIF-Bench

3.1 数据构成

包含来自 20 万用户的 1.2 亿条交互数据。
包含短视频 (Short Video), 广告 (Ad), 商品 (Product) 三类 items 的数据。
- Short Video: 提供曝光序列 (impression sequences) 以及对应的交互类型 (interaction type).
- Ad: 这对于带有产品链接的短视频而言的，提供用户的点击序列 (click sequences).
- Product: 提供用户的点击序列 (click sequences).
包含丰富的元数据：
- User-side: 一段结合了自然语言 token 和 itemic token 的叙述作为用户画像，包括年龄、性别、最近浏览、购物记录等等信息。
- Item-side: （在数据集找了一圈，不是很清楚这个 embedding 放哪了）
  - 4096 维文本 embedding
  - 5 帧的视觉 embedding，每帧 1152 维
  - 对视频详细的文本描述 (dense caption)。
- Interaction-side: 对于每个 user-video 对，提供交互类型，包括 like, follow, comment, effective view, dislike.
对于每个 item 都提供了对应的 RQ-code 。
以用户维度划分 train-test set，对于一个用户，以时间维度划分 history-target 。

3.2 任务设计

来源: https://arxiv.org/abs/2512.24762)

如表，按能力的高级程度，一共划分了四个层次，共 8 个任务。
$H$ 表示交互历史， $P$ 表示用户画像。
L0, L1, L3 看表格就很好理解，解释一下 L2 的两个任务

L2 任务示例，来源: https://arxiv.org/abs/2512.24762)

评测指标说明：
- LLM-as-Judge: 使用 LLM 评判输出与答案的相似度。
- Pass @ K: 表示生成的前 $K$ 个目标命中 Ground Truth 中的 items 占预测次数的比例。
- Recall @ K: 表示每次考虑前 $K$ 个目标的前提下，Ground Truth 中被命中的比例。
- 注意：一条指令中，Ground Truth 是一个集合，包含多个 items。所以是给出一个历史集合，预测 items 去击中一个 target 集合。
此外还补充了一些之前就有的 benchmark 的测试，包括数学、编程等等，用来检验模型对其它任务的泛化性。
详细的还是要自己去 hf 上看，有很清晰的文档，论文里写的有点泛了感觉。 OpenOneRec/OpenOneRec-RecIF · Datasets at HF Mirror

4 Pre-Training

4.1 Pre-Training Data

论文的附录提供了预训练数据的示例，非常的直观哦。o(￣▽￣)ブ

Itemic Token
- items，使用 RQ-Code 表示，共三层 $S_i = (s_a,s_b,s_c)$ ，每层码表大小为 8192 （即 8192 个聚类中心）。
- 转换为 token: <|item_begin|><item_a_5028><item_b_6733><item_c_2559><|item_end|>
Itemic Dense Caption Data
- 训练一个模型，输入 Itemic Token，输出相应的文字描述，形成物品的文字描述数据。
Swquential User Behavior Data
- 字面意思，这是 core training corpus 。
Interleaved User Persona Grounding Data
- 将 item 和用户的各种行为（性别年龄、交互历史等等）结合起来构成用户画像数据。

Kiraa

HSTU Embedding 学习笔记

Torchrec

数据结构

JaggedTensor (jt)

KeyedJaggedTensor (kjt)

模型

torch.nn.Embedding

EmbeddingCollection (EC)

torch.nn.EmbeddingBag

EmbeddingBagCollection (EBC)

HSTU Embedding

OneRev V2 学习笔记

OneRec V2

Kuaishou OneRec Family

Tokenizer

相似物品数据集构建

对比学习

RQ-Code

Multi-Scale Feature Engineering

User Static Pathway

Short-term Pathway

Positive-feedback PathWay

Lifelong Pathway

总结

Context Processor

Lazy Decoder Block

vLLM 学习笔记

什么是 vLLM

LLM 推理回顾：KV Cache 引入

Prefill

Decoding

PagedAttention：解决显存分配问题

KV Cache 带来的显存分配问题

PagedAttention 机制

Med3DVLM 模型架构及训练流程详解

训练阶段一：图文对比学习

Vision-Encoder 图像编码器: DCFormer

DecompConv3D 分解 3D 卷积

DecomposedStem 分解卷积 Stem 模块

ConvBlock 卷积块

1. 下采样 & 通道数调整

2. 经过 ConvBlock

DCFormer 总体架构

Text-Encoder 文本编码器: BERT

Loss Function 损失函数: SigLIP

训练

训练阶段二：VLM-Pretraining

Multi-Scale MLP-Mixer 多层次MLP混合器

Mixer Layer 特征混合块 (空间 + 通道)

高低层特征混合

Qwen2.5-7B 适配

训练

训练阶段三：VLM Fine-Tuning

LoRA 微调

训练

qwen3-0.6B 学习笔记

0 Qwen3 Technical Report

1 打印模型结构

2 模型结构整理

OpenOneRec 论文阅读笔记

0

1 Items as Tokens

1.1 Itemic Tokens

1.2 计算方法: Residual-Quantized Code, RQ Code

对比学习

RQ Code

2 推荐系统的自回归模型

3 RecIF-Bench

3.1 数据构成

3.2 任务设计

4 Pre-Training

4.1 Pre-Training Data

`JaggedTensor` (`jt`)

`KeyedJaggedTensor` (`kjt`)

`torch.nn.Embedding`

`EmbeddingCollection` (EC)

`torch.nn.EmbeddingBag`

`EmbeddingBagCollection` (`EBC`)