想象你是一家修表厂的学徒。老师傅看一眼整块机械表，就能凭整体印象说出它的特点；而你喜欢把表拆开，把齿轮、发条、螺丝这些小零件记在脑子里。FastText 就是那位拆件学徒。它不把单词当成一个不可分割的整体，而是先把单词拆成更小的字符 n-gram 小零件，再让这些小零件各自的向量“焊”成整个词的向量。这样一来，没见过的新词也能用熟悉零件拼出大致含义。更重要的是，FastText 还能把整句话的所有词与零件装进一个袋子，快速做出文本分类。它训练快、适应多语言、对低频词友好，是自然语言处理里性价比极高的入门利器。

岗位关联

学会 FastText，你将在实际项目中用最小的训练成本拿到可靠的词向量与文本分类基线，为后续深度学习模型提供清晰参照。

目录
  1. 可视化演示
  2. 词嵌入基础
  3. 子词n-gram
  4. FastText模型
  5. Word2Vec对比
  6. 文本分类应用
  7. 多语言支持
  8. 训练效率优化
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

本节配有交互动效（进入视口后自动加载，约 3KB）。

子词n-gram分解 边界符：添加<和> n-gram: 连续字符子串 v(word)=Σv(gram_i) 词向量=子词向量之和

词嵌入基础

想象修表厂仓库里堆满成千上万块机械表。最早给表做档案的管理员用“独热编号”：给每块表一个唯一的号，第几块表就把第几位标成 1，其他全是 0。编号很方便，但两块功能一模一样的表，编号之间没有任何相似之处，就像门牌号 2 号和 3 号看不出都产自同一个厂。

后来师傅改用“分布式表示”：每块表浓缩成一张规格表，包含产地、机芯类型、防水等级等数字特征。两张规格表越像，说明这两块表越接近。这就是词嵌入的基本思想——把词汇映射到低维稠密向量，让语义相似的词在向量空间里挨在一起。

用数学语言说，词嵌入就是查一张嵌入矩阵。假设词表大小是 |V|，我们准备一个 d×|V| 的矩阵 E；每个词 w 对应一个独热列向量 o_w，二者相乘就得到 d 维词向量 e_w。d 通常只有 100 至 300 维，远小于原来 |V| 维的稀疏空间。

有了规格表，FastText 并不满足于一张一张手写。它准备把表拆开，看看哪些零件可以通用——这正是下一节要讲的小零件（子词 n-gram）。

ew=E ow,E∈Rd×∣V∣\mathbf{e}_w = \mathbf{E}\,\mathbf{o}_w,\quad \mathbf{E}\in\mathbb{R}^{d\times|\mathcal{V}|}
这个公式说明：独热向量负责“选列”，嵌入矩阵负责“提供向量”，结果就是每个词的低维稠密表示。
  1. 词表规模\mathcal{V} 是所有单词的集合，|\mathcal{V}| 表示词表大小，例如十万个词。
    ∣V∣|\mathcal{V}|
  2. 独热向量\mathbf{o}_w 是一个只有第 w 位为 1、其余为 0 的列向量，作用像仓库门牌号。
    ow∈{0,1}∣V∣\mathbf{o}_w \in \{0,1\}^{|\mathcal{V}|}
  3. 嵌入矩阵\mathbf{E} 是 d 行、|V| 列的矩阵，每一列就是某个词待学习的向量。
    E∈Rd×∣V∣\mathbf{E}\in\mathbb{R}^{d\times|\mathcal{V}|}
  4. 矩阵相乘相乘等价于从 \mathbf{E} 中抽出 \mathbf{o}_w 置 1 的那一列，得到低维向量 \mathbf{e}_w。
    ew=E ow\mathbf{e}_w = \mathbf{E}\,\mathbf{o}_w

子词n-gram

修表师傅发现，同一家厂生产的表经常共用螺丝、齿轮和发条。与其为每块表单独写整张规格表，不如先把单词拆成更小的“字符窗口零件”。这个窗口在字符序列上滑动，每次抓 n 个字符，就是 n-gram 子词。

例如 playing 这个单词，前后加上边界符号 < 和 >（表示开头和结尾），按 n=3 滑窗，会得到 <pl、pla、lay、ayi、yin、ing、ng> 共 7 个零件。边界符让前缀、后缀信息也能被捕捉，比如 ng> 提示这是现在分词。

所有 n-gram 组成的集合记为 G_w。FastText 会给每个 n-gram 分配一个向量 z_g，而不是直接给整个单词一个“孤立编号”。为了不让零件库爆炸，工程上常用哈希技巧：把成千上万的 n-gram 折叠到 m 个小格子，用少量碰撞换取内存。

拆出的零件被统一收进零件库。下一步，FastText 要把这些零件向量“焊”在一起，拼出一整块表的向量。

Gw={ cici+1⋯ci+n−1∣i=1,…,L−n+1 }G_w = \{\, c_i c_{i+1}\cdots c_{i+n-1} \mid i=1,\dots,L-n+1 \,\}
这个公式描述拆词过程：在加了边界符的字符序列上，用固定大小的窗口一路滑过去，收集所有局部片段。
  1. 字符序列c_1 c_2 \cdots c_L 是加了边界符后的字符序列，L 为总长度。
    c1c2⋯cLc_1 c_2 \cdots c_L
  2. 窗口起点i 从 1 滑到 L-n+1，每次取连续 n 个字符。
    i=1,…,L−n+1i=1,\dots,L-n+1
  3. 取片拼接c_i c_{i+1}\cdots c_{i+n-1} 是从第 i 位开始的 n 长度片段。
    cici+1⋯ci+n−1c_i c_{i+1}\cdots c_{i+n-1}
  4. 集合表示用花括号收集所有片段，得到词 w 的零件集合 G_w。
    Gw={ cici+1⋯ci+n−1∣i=1,…,L−n+1 }G_w = \{\, c_i c_{i+1}\cdots c_{i+n-1} \mid i=1,\dots,L-n+1 \,\}

FastText模型

零件库建好了，每颗螺丝、齿轮上都贴了一小张“向量贴纸”。FastText 表示一个单词时，不像 Word2Vec 那样直接查整词表，而是把它包含的所有零件贴纸加起来，等于把“齿轮位置”、“发条长度”、“外壳材质”等信号叠成一份综合规格。

严格来说，词 w 的最终向量 v_w 就是它所有 n-gram 向量 z_g 的求和（也可以取平均）。由于 n-gram 在词与词之间大量共享，训练任何一个词都会顺带更新一大批通用零件；遇到从没见过的组合，也能用已有零件拼出向量。

训练过程依然放在“用中心词预测上下文”的框架里：每来一个词，就用它的 v_w 与上下文向量算相似度，再用梯度下降微调所有相关零件向量。为了让输出端不拖慢速度，FastText 使用层次 Softmax，把“在一万个词里找目标”变成大约 14 次二叉树判断。

这种“拼表”的思路让修表厂再也不怕新款表——只要表上有熟悉的零件，就能估出它的规格。这也是 FastText 与 Word2Vec 最本质的分水岭。

vw=∑g∈Gwzg\mathbf{v}_w = \sum_{g \in G_w} \mathbf{z}_g
词向量就是子词零件向量的总和。每个零件都贡献一小部分，最终拼出整个词的含义。
  1. n-gram 向量\mathbf{z}_g 是零件 g 对应的低维向量，在训练中不断更新。
    zg∈Rd\mathbf{z}_g \in \mathbb{R}^d
  2. 零件集合G_w 是来自上一节拆词得到的 n-gram 集合。
    Gw={g1,g2,…,gm}G_w = \{g_1, g_2, \dots, g_m\}
  3. 累加求和把集合中所有零件向量逐维度相加，得到词 w 的表示。
    vw=zg1+zg2+⋯+zgm\mathbf{v}_w = \mathbf{z}_{g_1} + \mathbf{z}_{g_2} + \cdots + \mathbf{z}_{g_m}

Word2Vec对比

Word2Vec 像一位只记整表外观的老师傅，他看一块表就记一张脸：run、running、runner 在他看来是三张完全不同的脸。FastText 则像拆件学徒，看到 running 会认出 run 的零件、ing 的后缀零件，立刻能猜出它和 run 关系密切。

对比最明显的是低频词与未登录词。Word2Vec 中一个词如果只出现几次，向量几乎学不好；未登录词（OOV）系统里根本没有，直接“查无此人”。FastText 里，低频词虽然整个词很少见，但它的内部子词常在其他高频词里出现，零件被反复训练，因此词向量依然可靠。

形态上有差异：FastText 对拼写相近、词形变化丰富的语言（如德语、土耳其语）更友好，代价是需要维护庞大的 n-gram 表。衡量两个词向量的相似度，通常用余弦相似度，取值范围 -1 到 1，越接近 1 表示方向越一致。

老师傅胜在省零件，拆件学徒胜在能应付新面孔。实际项目中，如果语料里充满产品名、拼写变体，FastText 的“零件思想”往往更稳。

sim(a,b)=a⋅b∥a∥∥b∥\mathrm{sim}(\mathbf{a},\mathbf{b}) = \frac{\mathbf{a}\cdot\mathbf{b}}{\|\mathbf{a}\|\|\mathbf{b}\|}
余弦相似度只看向量方向的夹角，不看长度，适合比较两个词向量是否语义相近。
  1. 内积\mathbf{a}\cdot\mathbf{b} 把两个向量对应位置相乘再求和。
    a⋅b=∑i=1daibi\mathbf{a}\cdot\mathbf{b} = \sum_{i=1}^{d} a_i b_i
  2. 范数\|\mathbf{a}\| 是向量长度，等于各分量平方和开根号。
    ∥a∥=∑i=1dai2\|\mathbf{a}\| = \sqrt{\sum_{i=1}^{d} a_i^2}
  3. 归一化内积除以两个长度，抵消向量大小影响，只看方向夹角。
    a⋅b∥a∥∥b∥=cos⁡θ\frac{\mathbf{a}\cdot\mathbf{b}}{\|\mathbf{a}\|\|\mathbf{b}\|} = \cos\theta

文本分类应用

修表厂还会接到整盒坏表的维修单，需要快速判断是“进水”、“缺件”还是“卡机”。FastText 开箱即用的文本分类模型，不看语法，只把整句话所有词和字符 n-gram 倒进一个麻袋，搅一搅取平均，便得到整句向量。

形式上，句子 x 的特征集合是词袋与字符 n-gram 的并集；所有特征向量求平均得到 h。随后 h 经过一层线性变换接 softmax，变成每个类别的概率。这本质上是一个“用平均零件清单投票”的线性分类器。

fastText 分类器还采用层次 Softmax 和多线程训练，百万量级的句子几分钟即可训练完成。因此在工业界，它常被当作第一个基线模型：先拿 fastText 跑一遍，再决定要不要上更贵的深度模型。

工业现场不看花哨，只看效率和够用。按零件清单一锅炖的分类方式虽然朴素，却常常以极低成本达到接近深度模型的效果，也因此成为文本分类的“第一块试金石”。

P(y∣x)=exp⁡(uy⊤h)∑j=1Cexp⁡(uj⊤h)P(y\mid x) = \frac{\exp(\mathbf{u}_y^\top \mathbf{h})}{\sum_{j=1}^{C} \exp(\mathbf{u}_j^\top \mathbf{h})}
句子先被平均成一个向量，再与每个类别的标准向量做指数打分，最终归一化成概率。
  1. 句子向量\mathbf{h} 是句子中所有特征向量（词与 n-gram）的平均。
    h=1∣Fx∣∑f∈Fxvf\mathbf{h} = \frac{1}{|F_x|}\sum_{f\in F_x}\mathbf{v}_f
  2. 类别向量\mathbf{u}_y 是类别 y 对应的输出向量，相当于类别的“标准规格”。
    uy∈Rd\mathbf{u}_y \in \mathbb{R}^d
  3. 指数打分\exp(\mathbf{u}_y^\top \mathbf{h}) 计算句子与类别 y 的匹配分数，分子是目标类分数。
    exp⁡(uy⊤h)\exp(\mathbf{u}_y^\top \mathbf{h})
  4. softmax 归一化除以所有 C 个类别分数之和，保证输出为概率分布。
    ∑j=1Cexp⁡(uj⊤h)\sum_{j=1}^{C} \exp(\mathbf{u}_j^\top \mathbf{h})

多语言支持

修表厂接到海外订单，发现英文表、法文表、德文表居然共用同一批螺丝和齿轮——因为它们都靠拉丁字母拼写。FastText 干脆用全球统一的“字符零件箱”处理多种语言，拼写相近的词自然共享大量 n-gram 零件。

比如英文 information 和法文 information，字符级 n-gram 高度重叠，于是两个词向量在没有双语词典的情况下也会天然靠近。这是跨语言对齐里一种很弱的信号：不能替代完整映射，但足以帮模型在缺少平行语料时抓住拼写线索。

对低资源语言尤其宝贵：语料只有几万句，整词统计稀疏，但共享字符表让模型能从相近语言“借”到零件。FastText 官方提供的多语言词向量，就用这种机制覆盖了 157 种语言。

国际订单靠“通用零件”大大降低了翻译成本。当然，如果两种语言使用完全不同的文字（如中文和英文），字符层面没有交集，这个机制就失效了。

Nshared(a,b)=∣Gwa∩Gwb∣N_{\text{shared}}(a,b) = \left| G_{w_a} \cap G_{w_b} \right|
两个词共享的 n-gram 越多，向量就越可能靠近。这就是 FastText 跨语言能力的来源。
  1. 两个词集合G_{w_a}、G_{w_b} 分别表示语言 a、b 中两个词的 n-gram 零件集合。
    Gwa⊆G,Gwb⊆GG_{w_a} \subseteq \mathcal{G},\quad G_{w_b} \subseteq \mathcal{G}
  2. 集合交集\cap 取两边共同拥有的 n-gram，比如共同字母组合。
    Gwa∩GwbG_{w_a} \cap G_{w_b}
  3. 数量计数|\cdot| 统计交集中零件个数，共享越多，向量越容易相互靠近。
    Nshared(a,b)=∣Gwa∩Gwb∣N_{\text{shared}}(a,b) = |G_{w_a} \cap G_{w_b}|

训练效率优化

订单越来越多，修表厂要提效。FastText 的“快”不是靠更高级的 GPU，而是三把钥匙：共享零件减少无效劳动、输出端二叉树加速、多工人并行流水线。

输出端方面，层次 Softmax 把词表组织成 Huffman 树，高频词离根近，每次训练只需沿树走 O(log|V|) 步；负采样则干脆每次只选几个反例，连树都不用走。二者都能避免在全词表上做百万级别归一化。

工程实现上，fastText 支持多线程、梯度裁剪与模型量化。量化的思路是把向量从 32 位浮点压成 8 位整数，精度损失很小，但模型体积缩小数倍，内存占用大幅下降。

流水线共享零件、目录快速查找、工人并行分工——这三招让 FastText 既能打、又便宜，成为自然语言处理里最实用的“万金油”之一。

Lneg=−log⁡σ(vw⊤uc)−∑w~∈Nlog⁡σ(−vw⊤uw~)\mathcal{L}_{\text{neg}} = -\log\sigma(\mathbf{v}_w^\top \mathbf{u}_c) - \sum_{\tilde{w}\in N} \log\sigma(-\mathbf{v}_w^\top \mathbf{u}_{\tilde{w}})
负采样损失只更新少量正例与负例，避免每次计算整个词表的概率，是训练提速的关键。
  1. 正例得分\mathbf{v}_w 是中心词向量，\mathbf{u}_c 是上下文词 c 的向量，二者内积越大越好。
    vw⊤uc\mathbf{v}_w^\top \mathbf{u}_c
  2. sigmoid 压缩\sigma(z)=1/(1+e^{-z}) 把实数映射到 0-1，当作“这个词是正例”的概率。
    σ(z)=11+e−z\sigma(z) = \frac{1}{1+e^{-z}}
  3. 负样本集N 是随机挑出的少量非目标词，用 \tilde{w} 表示。
    N={w~1,w~2,…,w~k}N = \{\tilde{w}_1, \tilde{w}_2, \dots, \tilde{w}_k\}
  4. 两项相加第一项提高正例概率，第二项压低负例概率，从而在极小代价下完成一次更新。
    Lneg=−log⁡σ(vw⊤uc)−∑w~∈Nlog⁡σ(−vw⊤uw~)\mathcal{L}_{\text{neg}} = -\log\sigma(\mathbf{v}_w^\top \mathbf{u}_c) - \sum_{\tilde{w}\in N}\log\sigma(-\mathbf{v}_w^\top \mathbf{u}_{\tilde{w}})

AI 应用场景

电商评论分类基线

阶段：数据准备与建模

解决的问题：电商平台每天产生上百万条评论，人工规则难以覆盖口语化表达。传统词频模型忽略词形变化，无法处理“难用”“不好用”等未登录词。FastText 用词袋加字符 n-gram 自动吸收变形词，可在 10 分钟内产出一个可上线的基线。

具体案例：某电商团队用 fastText 对“物流快，包装好”等评论做情感二分类，先训练 5000 条标注数据，准确率达 0.86，再用该基线筛选难例交给 BERT 迭代。

多语言客服工单分类

阶段：模型训练与部署

解决的问题：跨国客服工单涉及英语、法语、德语，若每个语种单独建模，标注成本高。FastText 共享字符表，一个模型可同时处理拼写相近的多语言文本，适合小语种冷启动。

具体案例：某 SaaS 公司在 fastText 预训练多语言词向量上微调分类器，将工单分为“账单、技术、退货”三类，对法语和西班牙语准确率比单语词向量提升约 4 个百分点。

搜索召回中的拼写变体匹配

阶段：召回与特征计算

解决的问题：用户搜索 running shoes 时，文档里写的是 run shoe；传统精确匹配漏召回。FastText 子词词向量可以让拼写相近词获得较近向量，从而提升召回。

具体案例：某电商搜索团队用 FastText 对商品标题训练词向量，将 laptop 与 laptops、notebook 的相似度纳入召回候选，曝光点击率提升 2.1%。

Python 演示

python100 行
import mathimport randomfrom collections import Counter  def build_ngrams(word, n=3):    word = "<" + word + ">"    return [word[i:i+n] for i in range(len(word) - n + 1)]  class FastTextClassifier:    def __init__(self, labels, dim=8, lr=0.1, epochs=5):        self.labels = labels        self.dim = dim        self.lr = lr        self.epochs = epochs        self.emb = {}        self.out = {label: [0.0] * dim for label in labels}        self.rng = random.Random(42)     def _vec(self, key):        if key not in self.emb:            self.emb[key] = [self.rng.uniform(-0.1, 0.1) for _ in range(self.dim)]        return self.emb[key]     def features(self, text):        feats = []        for w in text.split():            feats.append(w)            feats.extend(build_ngrams(w))        return feats     def predict_proba(self, text):        feats = self.features(text)        if not feats:            feats = ["<unk>"]        h = [0.0] * self.dim        for f in feats:            v = self._vec(f)            for i in range(self.dim):                h[i] += v[i]        for i in range(self.dim):            h[i] /= len(feats)        scores = {}        for label, u in self.out.items():            s = sum(h[i] * u[i] for i in range(self.dim))            scores[label] = math.exp(s)        total = sum(scores.values())        return {k: v / total for k, v in scores.items()}     def train(self, texts, ys):        data = list(zip(texts, ys))        for _ in range(self.epochs):            self.rng.shuffle(data)            for text, y in data:                prob = self.predict_proba(text)                feats = self.features(text)                h = [0.0] * self.dim                for f in feats:                    v = self._vec(f)                    for i in range(self.dim):                        h[i] += v[i]                for i in range(self.dim):                    h[i] /= len(feats)                for label, u in self.out.items():                    err = (1.0 if label == y else 0.0) - prob[label]                    for i in range(self.dim):                        u[i] += self.lr * err * h[i]                grad_h = [0.0] * self.dim                for label, u in self.out.items():                    err = (1.0 if label == y else 0.0) - prob[label]                    for i in range(self.dim):                        grad_h[i] += err * u[i]                for f in feats:                    v = self._vec(f)                    for i in range(self.dim):                        v[i] += self.lr * grad_h[i] / len(feats)     def predict(self, text):        prob = self.predict_proba(text)        return max(prob, key=prob.get)  def main():    texts = [        "fast shipping great packaging",        "love this phone battery lasts",        "slow delivery poor quality",        "camera is weak and blurry",    ]    labels = ["good", "good", "bad", "bad"]    model = FastTextClassifier(["good", "bad"])    model.train(texts, labels)    for t in texts:        print(t, "->", model.predict(t))    print("new word:", model.predict("amazing fast delivery"))  if __name__ == "__main__":    main()
目的：实现一个简化版 FastText 文本分类器，用词与字符 n-gram 特征训练多分类逻辑回归，演示“拆零件 + 平均 + softmax”的全流程。
  1. build_ngrams(word, n=3)给单词加边界符并用滚动窗口拆出字符 n-gram，对应正文的“拆零件”步骤。
  2. self.emb保存每个词和 n-gram 的向量，等价于零件库里的“向量贴纸”。
  3. features(text)把句子里所有词和字符 n-gram 收集成一个特征袋，对应“整句话倒进麻袋”。
  4. predict_proba先平均所有特征向量得到句子向量 h，再算 softmax 概率，对应文本分类的投票过程。
  5. train用随机梯度下降同时更新类别向量和特征向量，体现 fastText 的轻量训练方式。

常见误区

误区FastText 名字里带“Fast”，又是后来的模型，肯定在所有任务上都比 Word2Vec 强，直接替换就好。

正解FastText 的核心优势在于子词 n-gram 带来的低频词、OOV 处理能力，但对高频词和某些语义任务不一定优于 Word2Vec；而且它的文本分类器是独立的一套线性模型，不能和词嵌入模型混为一谈。选型要看任务是否需要形态信息。

为何常见：两者都产出词向量，流程相似，新人容易把“更新”理解为“全面超越”。

误区既然 FastText 能拼出新词，那训练时没见过的词它都能生成向量，彻底解决 OOV。

正解FastText 只能拼出“训练字符表内出现过”的子词。如果新词包含从未见过的字符，或语言完全不同（如中文和英文），子词没有交集，依然无法有效表示。边界是字符级共享，不是魔法。

为何常见：演示案例通常选拼写变体，容易让人忽略底层字符表的存在。

误区子词 n-gram 能捕捉形态信息，那把 n 设大一点，比如 10，不是能捕捉更长的词缀吗？

正解n 太大会失去泛化能力，n-gram 几乎等于整词，低频词的零件复用优势消失；同时零件数量暴涨，内存失控。FastText 默认 3-6 是权衡形态覆盖与泛化后的结果。

为何常见：直觉认为“信息越多越好”，忽略了特征数量和泛化能力的曲线关系。

误区深度学习时代，文本分类至少得是 LSTM 或 Transformer，fastText 能这么好用，内部结构一定也很深。

正解fastText 分类器本质是“词袋 + 字符 n-gram 平均 + 线性 softmax”，没有任何隐藏层或注意力机制。它的强大来自 n-gram 特征和高效训练，而不是网络深度。

为何常见：看到“自然语言处理”就联想到深度神经网络，忽视了大量工业基线其实很朴素。

面试题

Q1. FastText 词嵌入的核心创新是什么？

单选题 · easy

  • A.将词拆成子词特征← 正确答案
  • B.使用全局共现矩阵
  • C.仅训练上下文窗口
  • D.增强对抗生成网络

答案：A。FastText 的核心是子词 n-gram，把词拆成小零件再累加成词向量。全局共现矩阵是 GloVe 的思路，上下文窗口是 Word2Vec 的训练方式，对抗生成网络与 FastText 无关。

Q2. FastText 中 n-gram 主要来自以下哪个层面？

单选题 · easy

  • A.字符级子词切片← 正确答案
  • B.词级共现统计次数
  • C.句子级语法结构
  • D.文档级主题分布

答案：A。FastText 在字符序列上滑动窗口生成 n-gram，属于字符级子词切片。词级共现是统计模型的思路，句法和主题都远超 FastText 的输入范围。

Q3. 以下哪个是 FastText 处理未知词的方式？

单选题 · easy

  • A.返回随机的零向量
  • B.复用已有子词向量← 正确答案
  • C.从外部语料中查找
  • D.训练时直接丢弃它

答案：B。未知词虽然没有整词向量，但它仍可被拆成字符 n-gram，这些零件可能已在其他词中出现过，于是能复用零件向量拼出近似表示。返回零向量、外部查找、丢弃都不是 FastText 的机制。

Q4. fastText 文本分类模型的输入特征是什么？

单选题 · mid

  • A.整句词袋与子词袋← 正确答案
  • B.上下文窗口的共现
  • C.词性标注的全序列
  • D.依存句法分析树形

答案：A。fastText 分类器把整句话的所有词和字符 n-gram 放进一个袋子，取平均得到句子向量。上下文窗口用于词嵌入训练，词性和依存句法属于结构化语法信息，fastText 并不使用。

Q5. 层次 Softmax 的主要优势是？

单选题 · mid

  • A.将输出复杂度降低← 正确答案
  • B.提高词向量维度
  • C.自动消除语义歧义
  • D.无需任何训练数据

答案：A。层次 Softmax 把词表组织成树，训练时只需沿树走 O(log|V|) 步，而普通 softmax 需要遍历全词表。它不改变向量维度，也不能消除歧义，更不可能免训练。

Q6. FastText 训练快的原因是什么？

单选题 · mid

  • A.用负采样与层次化← 正确答案
  • B.采用深度循环网络
  • C.引入自注意力机制
  • D.使用卷积特征提取
  • E.共享字符表形成重叠
  • F.人工双语对齐词典
  • G.要求语料双语平行
  • H.训练统一词表空间

答案：A。FastText 让多种语言共享同一套字符级 n-gram，拼写相近的词会产生子词重叠，进而让向量靠近。它不需要双语词典或平行语料；训练统一词表空间是另一种跨语言对齐思路，不是 FastText 的核心机制。

Q7. 下列哪些是 fastText 文本分类器的特点？

多选题 · mid

  • A.输入整句词袋特征← 正确答案
  • B.常用于任务型分类← 正确答案
  • C.输出层使用层次化← 正确答案
  • D.必须使用卷积网络

答案：ABC。fastText 分类器输入整句词袋与子词袋，常被用于情感分析、工单分类等任务，输出层常用层次 Softmax 加速。它不依赖卷积网络，卷积是 CNN 的分类思路。

Q8. FastText 相比 Word2Vec 有哪些优势？

多选题 · hard

  • A.更好处理低频词语← 正确答案
  • B.能生成未知词向量← 正确答案
  • C.更好利用词内形态← 正确答案
  • D.保留原始上下文窗口

答案：ABC。FastText 通过子词共享，让低频词能借用高频词里的零件，也能为未见过的词拼出向量，同时对词形变化更敏感。保留原始上下文窗口是 Word2Vec 本来就有的特性，不是 FastText 的优势。

Q9. 下列哪些技巧能提升 fastText 文本分类训练效率？

多选题 · hard

  • A.层次化输出树结构← 正确答案
  • B.并行多线程训练法← 正确答案
  • C.使用特征哈希降维← 正确答案
  • D.全词袋套索惩罚项

答案：ABC。层次 Softmax 用树结构降低输出复杂度，多线程并行提升吞吐，特征哈希压缩 n-gram 表节省内存。套索惩罚是正则化手段，并不直接提升训练效率。