FastText 分析与实践

最新推荐文章于 2024-08-19 16:01:20 发布

weixin_30897079

最新推荐文章于 2024-08-19 16:01:20 发布

阅读量248

点赞数 1

文章标签：数据结构与算法人工智能

原文链接：http://www.cnblogs.com/ExMan/p/9858350.html

版权

一. 前言

自然语言处理(NLP)是机器学习，人工智能中的一个重要领域。文本表达是 NLP中的基础技术，文本分类则是 NLP 的重要应用。在 2016 年， Facebook Research 开源了名为 fasttext[1] 的文本表达和分类的计算库。 fasttext 是基于文章 [2], [3], [4] 所提出算法的实现，针对变形词汇表达，线性分类优化提供了优秀的解决方案。本文试图梳理 FastText 在文本表达和文本分类方面的工作，并进行实践。

二. 词嵌入

1. 背景介绍

词表达是 NLP 处理中的关键技术。常见的方式如 one-hot，使用了高维稀疏向量表示词汇，这样的特征可以反映词出现的频率，却不能反映词之间的关系。与此对应，词嵌入技术将词汇的上下文关系嵌入一个低维空间，其中比较有代表性的方法如 word2vec [5]， GloVe[6]。本段落将分析 word2vec 的原理。

2. word2vec

word2vec 将词的上下文关系嵌入到低维空间。更具体而言，word2vec 将词的上下文关系转换为分类关系，并以此同时训练词嵌入向量和 logistic regression 分类器。

1. 逻辑回归

logistic regression 是经典的线性分类模型。广义上而言，线性模型由三个部分组成， 1. 输入向量 2. 线性系数 3. 偏移(bias)，而 bias 可以进一步表示成线性系数。所以，二分类的线性分类问题可以表示为输入 $x$ 和系数 $w$ 的内积结果 $w^Tx$，结果的正负决定了数据的类别。分类器参数通过最小化损失函数 $l(y, w^Tx)$来完成，不同的损失函数定义了不同的分类模型。

下面列举了svm， lr 的损失函数，其中 $y\in \{-1, 1\}$
logit : $\Sigma_{i=1}^N ln(1 + e^{-y_i w^Tx_i})$
svm : $\Sigma_{i=1}^N max(0, 1- y _iw^Tx_i) + \lambda||w||^2$

logistic regression 也广泛地应用在多分类问题中，通过 softmax 函数计算数据属于每个类别的概率完成分类。因为分类神经网络的输出层通常也设定为 softmax 函数，所以多分类 lr 也可以表示为浅层神经网络。

下面我们分析 word2vec 如何将词的上下文关系转化为分类任务。

2. skip-gram

我们将词的上下文定义为以词 $w_i$ 为中心，窗口为 $k$ 前后范围内的词 $C_i = {w_{i-k}, w_{i-k+1}, ..., w_{i-1}, w_{i+1}, ... w_{i+k}}$。

skip-gram 将词之间的关系变成了 $|V|$ 多分类问题，其中 $|V|$ 是词库大小。每个词有两个变量 $x_i, w_i$，前者为词嵌入向量，后者是线性分类器的系数，在相关文章中又称为上下文向量。

skip-gram 用中心词汇来预测其上下文，如下图：

skip-gram.png

3. cbow

Continuous bag of words(cbow) 是与 skip-gram 相对应的另一种将上下文转化为分类任务的方式。

image.png

上图显示 cbow 用上下文词向量的加和结果来预测其中心词汇，其它的方式还有拼接。需要注意的是拼接的方式会导致上下文向量 $c_i$ 维度增大 $2 k$ 倍数， $k$ 为上下文窗口。

4. 针对多分类的计算优化

word2vec 将上下文关系转化为多分类任务，进而训练逻辑回归模型，这里的类别数量是 $|V|$ 词库大小。通常的文本数据中，词库少则数万，多则百万，在训练中直接训练多分类逻辑回归并不现实。

word2vec [5] 中提供了两种针对大规模多分类问题的优化手段， negative sampling 和 hierarchical softmax。以 skip-gram 为例，中心词对上下文的词类是正面例子，对所有其它的词则是负面例子。在优化中，negative sampling 只更新少量负面类，从而减轻了计算量。hierarchical softmax 将词库表示成前缀树，从树根到叶子的路径可以表示为一系列二分类器，一次多分类计算的复杂度从 $|V|$ 降低到了树的高度。

3. 总结

词嵌入技术将词的上下文关系嵌入到低维空间。word2vec 将词的局部上下文转化为了多分类任务，从而训练逻辑回归模型，并将逻辑回归模型中的输入部分作为词嵌入输出。

三. FastText 子词嵌入

1. 背景介绍

词嵌入技术在 NLP 领域发挥了越来越大的作用，相较于 one-hot 特征，词嵌入具有维度低，体现词间关系等特点。但传统的词嵌入技术忽略了词的微变形特性，如英语中动词的第三人称，进行时或过去时变形。针对这个问题， [2] 提出使用子词来学习词的表达，每个词由内部的 n-gram 字母串组成。在中文处理中， [7] 提出了类似的算法。

2. FastText 的实现

FastText 的子词嵌入在 word2vec 的基础上，引入了子词这个因素，从而使得词的微变形关系也能映射到嵌入空间中。

1. 子词

在 fasttext 中，每个词被看做是 n-gram 字母串包。为了区分前后缀情况，"<"， ">" 符号被加到了词的前后端。除了词的子串外，词本身也被包含进了 n-gram 字母串包。以 where 为例，$n=3$ 的情况下，其子串分别为
<wh, whe, her, ere, re>，以及其本身 <where>

注意，这里的 her 与单词 <her> 是不同的。

现在我们看看 fasttext 具体是怎么计算子串的。

void Dictionary::initNgrams() {
  for (size_t i = 0; i < size_; i++) { // 加入前后缀符号 <, > std::string word = BOW + words_[i].word + EOW; // 词本身作为特殊子串加入包中 words_[i].subwords.push_back(i); // 计算并将词子串加入包中 computeNgrams(word, words_[i].subwords); } } // 计算词子串 void Dictionary::computeNgrams(const std::string& word, std::vector<int32_t>& ngrams, std::vector<std::string>& substrings) const { for (size_t i = 0; i < word.size(); i++) { std::string ngram; if ((word[i] & 0xC0) == 0x80) continue; for (size_t j = i, n = 1; j < word.size() && n <= args_->maxn; n++) { ngram.push_back(word[j++]); // 将 utf-8 编码数据部分推入 ngram while (j < word.size() && (word[j] & 0xC0) == 0x80) { ngram.push_back(word[j++]); } if (n >= args_->minn && !(n == 1 && (i == 0 || j == word.size()))) { // fasttext 使用 open hash 进行 string->int 转换 int32_t h = hash(ngram) % args_->bucket; ngrams.push_back(nwords_ + h); substrings.push_back(ngram); } } } }

在 fasttext 中，minn 和 maxn 参数控制了子串的长度，其默认值分别为 3, 6。再以 where 为例，在默认子串参数情况下，其子串包内容为:

<wh, <whe, <wher, <where, whe, wher, where, where>, her, here, here>, ere, ere>, re> 以及自身 <where>

下面我们看 fasttext 是如何用子串来构造词嵌入的，这里注意每个子串也有自身的嵌入表示。

void Model::computeHidden(const std::vector<int32_t>& input, Vector& hidden) const { assert(hidden.size() == hsz_); hidden.zero(); for (auto it = input.cbegin(); it != input.cend(); ++it) { if(quant_) { // product quantization 优化 // 子串加和 hidden.addRow(*qwi_, *it); } else { // 子串加和 hidden.addRow(*wi_, *it); } } // 平均 hidden.mul(1.0 / input.size()); }

代码非常简明直接，每个词是其子串嵌入表示的加和平均。

fasttext 的另一个优势，是学习未知词的表达。以 working 为例，如果这个词在学习文本中没有出现过，但文本包含了 work, 和 ing，那么 working 的词嵌入向量也能够合理地计算出来。

2. skip-gram

一个词的嵌入是其子串嵌入的加和平均。当这个嵌入表示计算出来后，后续步骤与 word2vec 的 skip-gram 相同。下面是 fasttext 的 skip-gram 实现代码：

void FastText::skipgram(Model& model, real lr,
                        const std::vector<int32_t>& line) { std::uniform_int_distribution<> uniform(1, args_->ws); for (int32_t w = 0; w < line.size(); w++) { // 窗口大小 int32_t boundary = uniform(model.rng); const std::vector<int32_t>& ngrams = dict_->getNgrams(line[w]); for (int32_t c = -boundary; c <= boundary; c++) { if (c != 0 && w + c >= 0 && w + c < line.size()) { // 通过 ngrams 计算 line[w] 的表示，通过逻辑回归优化 ngrams 的嵌入表示 model.update(ngrams, line[w + c], lr); } } } }

我们来详细看看 Model::update 函数是怎么用逻辑回归来优化 ngrams 的嵌入表示

void Model::update(const std::vector<int32_t>& input, int32_t target, real lr) {
  assert(target >= 0);
  assert(target < osz_);
  if (input.size() == 0) return; // 子串加权平均得到词嵌入表示 computeHidden(input, hidden_); // 针对分类问题的 3 种处理 // 1. negative sampling 优化 if (args_->loss == loss_name::ns) { loss_ += negativeSampling(target, lr); } // 2. hierarchical softmax 优化 else if (args_->loss == loss_name::hs) { loss_ += hierarchicalSoftmax(target, lr); } // 3. 直接计算多分类逻辑回归 // 在文本分类模式下使用 else { loss_ += softmax(target, lr); } nexamples_ += 1; // 逻辑回归产生了导数，在文本分类情况下导数向量需要除以子串数量 if (args_->model == model_name::sup) { grad_.mul(1.0 / input.size()); } // 将导数直接加到子串向量中 for (auto it = input.cbegin(); it != input.cend(); ++it) { wi_->addRow(grad_, *it, 1.0); } }

在第二段，我们简单介绍了针对大量多分类的优化策略, negative sampling 和 hierarchical sampling。这里我们看看 fasttext 是怎样实现这些策略。

// 根据词频构构建采样表
void Model::initTableNegatives(const std::vector<int64_t>& counts) { real z = 0.0; for (size_t i = 0; i < counts.size(); i++) { z += pow(counts[i], 0.5); } // 每个词类在采样表中数量与其词频开方成比例 for (size_t i = 0; i < counts.size(); i++) { real c = pow(counts[i], 0.5); for (size_t j = 0; j < c * NEGATIVE_TABLE_SIZE / z; j++) { negatives.push_back(i); } } std::shuffle(negatives.begin(), negatives.end(), rng); } // 负采样 real Model::negativeSampling(int32_t target, real lr) { real loss = 0.0; grad_.zero(); // 负采样 args_->neg 个类别 for (int32_t n = 0; n <= args_->neg; n++) { if (n == 0) { // 将当前词作为正面例子对 target 类进行二分逻辑回归训练 loss += binaryLogistic(target, true, lr); } else { // 将当前词作为负面例子对负采样类进行二分逻辑回归训练 loss += binaryLogistic(getNegative(target), false, lr); } } return loss; } // 负采样一个类 int32_t Model::getNegative(int32_t target) { int32_t negative; // 轮询采样表 do { negative = negatives[negpos]; negpos = (negpos + 1) % negatives.size(); } while (target == negative); return negative; }

下面我们看看 hierarchical softmax 的实现

// 根据词频构造前缀树，因为树的内部节点数量为 |V| - 1 所以可以用 |V| * 2 的数组存储树结构
void Model::buildTree(const std::vector<int64_t>& counts) { tree.resize(2 * osz_ - 1); for (int32_t i = 0; i < 2 * osz_ - 1; i++) { tree[i].parent = -1; tree[i].left = -1; tree[i].right = -1; tree[i].count = 1e15; tree[i].binary = false; } for (int32_t i = 0; i < osz_; i++) { tree[i].count = counts[i]; } int32_t leaf = osz_ - 1; int32_t node = osz_; for (int32_t i = osz_; i < 2 * osz_ - 1; i++) { int32_t mini[2]; for (int32_t j = 0; j < 2; j++) { if (leaf >= 0 && tree[leaf].count < tree[node].count) { mini[j] = leaf--; } else { mini[j] = node++; } } tree[i].left = mini[0]; tree[i].right = mini[1]; tree[i].count = tree[mini[0]].count + tree[mini[1]].count; tree[mini[0]].parent = i; tree[mini[1]].parent = i; tree[mini[1]].binary = true; } for (int32_t i = 0; i < osz_; i++) { std::vector<int32_t> path; std::vector<bool> code; int32_t j = i; while (tree[j].parent != -1) { path.push_back(tree[j].parent - osz_); code.push_back(tree[j].binary); j = tree[j].parent; } paths.push_back(path); codes.push_back(code); } } // 用 hierarchical softmax 进行多分类计算 real Model::hierarchicalSoftmax(int32_t target, real lr) { real loss = 0.0; grad_.zero(); // 词的 0，1 表示 const std::vector<bool>& binaryCode = codes[target]; // 词到树根的路径 const std::vector<int32_t>& pathToRoot = paths[target]; for (int32_t i = 0; i < pathToRoot.size(); i++) { // 路径上的节点对应二分类， 0,1 编码决定分类 // 用二分逻辑回归进行训练 loss += binaryLogistic(pathToRoot[i], binaryCode[i], lr); } return loss; }

最后我们看一下二分逻辑回归的实现。

// 用一个正/负面例子更新二分逻辑回归模型
real Model::binaryLogistic(int32_t target, bool label, real lr) {
  real score = sigmoid(wo_->dotRow(hidden_, target));
  real alpha = lr * (real(label) - score);
  grad_.addRow(*wo_, target, alpha);
  wo_->addRow(hidden_, target, alpha);
  if (label) { return -log(score); } else { return -log(1.0 - score); } }

3. cbow

第二段讲解了 cbow 的原理是用中心词的上下文来预测中心词, 这里我们看看 fasttext 是如何实现 cbow 的。

void FastText::cbow(Model& model, real lr,
                    const std::vector<int32_t>& line) { std::vector<int32_t> bow; std::uniform_int_distribution<> uniform(1, args_->ws); for (int32_t w = 0; w < line.size(); w++) { int32_t boundary = uniform(model.rng); bow.clear(); for (int32_t c = -boundary; c <= boundary; c++) { // 将上下文的子字符串加入包中 if (c != 0 && w + c >= 0 && w + c < line.size()) { const std::vector<int32_t>& ngrams = dict_->getNgrams(line[w + c]); bow.insert(bow.end(), ngrams.cbegin(), ngrams.cend()); } } // 用所有子字符串来预测中心词，从而更新参数 model.update(bow, line[w], lr); } }

fasttext 的处理非常简洁，将上下文的子串全部加和平均作为输入去预测中心词。

3. 总结

fasttext 利用子词改良了词嵌入的质量，在嵌入学习中考虑了词的内部结构。在具体实现中， fasttext 用子词向量的加和平均表示词向量, 提供了 skip-gram 和 cbow 模式训练词嵌入表达。

四. FastText 线性文本分类优化

1. 背景介绍

对于文本分类而言，线性分类器往往能够达到非常优秀，媲美深度模型的效果。通常，线性模型的参数数量与词库大小相关，导致模型规模巨大。 fasttext 针对线性分类器模型进行了诸多优化，在不显著损失分类器精度的情况下，减少了内存使用和计算时间。

2. fasttext 分类模型架构

fasttext 的词嵌入是通过分类学习完成的，所以词嵌入和文本分类模型可以用下图统一表示。

Model Architecture.png

其中 $x_1, ..., x_N$ 表示一个文本中的 ngram 向量，一个文本的表示是所有 ngram 的加和平均。这和前文中提到的 cbow 相似，cbow 用上下文的 ngram 去预测中心词，而此处用全部的 ngram 去预测指定类别。

与前文词嵌入模型一样， fasttext 模型在进行文本分类监督训练时，既学习词嵌入表达，也学习分类器线性系数。

3. 优化

1. 子空间量化

product quantization [8] 是一种保存数据间距离的压缩技术。PQ 用一个码本来近似数据，与传统的 keams 训练码本不同的是， PQ 将数据空间划分为 k 个子空间，并分别用 kmeans 学习子空间码本。数据的近似和重建均在子空间完成，最终拼接成结果。

在 fasttext 中，子空间码本大小为 256，可以用 1 byte 表示。子空间的数量在 [2, d/2] 间取值。

除了用 PQ 对数据进行量化压缩，fasttext 还提供了对分类系数的 PQ 量化选项。

PQ 的优化能够在不影响分类其表现的情况下，将分类模型压缩为原大小的 $\frac{1}{10}$。

2. 裁剪字典内容

fasttext 提供了一个诱导式裁剪字典的算法，保证裁剪后的字典内容覆盖了所有的文章。具体而言，fasttext 存有一个保留字典，并在线处理文章，如果新的文章没有被保留字典涵盖，则从该文章中提取一个 norm 最大的词和其子串加入字典中。

字典裁剪能够有效将模型的数量减少，甚至到原有的 $\frac{1}{100}$。

4. 总结

fasttext 利用 Product Quantization 对字典中的词嵌入向量进行了压缩，并使用诱导式字典方法，构造涵盖全部文本的字典。两者结合，能够在不明显损害分类算法表现的情况下，将分类模型大小减小数百倍。

五. 实践

本段我们对词嵌入进行实践。词嵌入的比较有两种方式，直接比较是验证词表达保存了人为标注的词间关系，间接比较则是通过使用嵌入表达向量进行进一步学习，比如情绪预测[5]，通过模型的表现判断词嵌入的质量。

我们用中文维基数据 [9] 进行了训练，fasttext 的参数使用默认值， epoch 设置为50。此外 facebook 还提供了训练好的多国语言表达 [10].

以下我们分别用 nn(最近邻) 对中文维基训练结果进行实践：

// 乒乓球的近似词汇
Query word? 乒乓球
壁球 0.837808
曲棍球 0.792717
网球 0.792332 排球 0.789665 手球 0.780589 田径 0.780279 桌球 0.778775 举重 0.776161 沙滩排球 0.775708 乒乓球队 0.772797

// "男乒乓球" 并不存在， fasttext 仍然可以得到合理结果
Query word? 男乒乓球
乒乓球 0.767142
中国男子乒乓球队 0.725763
兵乓球 0.691391
体操 0.688922
张怡宁 0.688578
陈若琳 0.681761
跳水队 0.678217
打乒乓球 0.677547
王楠 0.671578
吴敏霞 0.669105

六. 总结

fasttext 是 facebook 开源的关于文本表达和文本分类的计算库。fasttext 结合词的子串信息计算词表达，提高了对微变形词汇的学习。针对文本分类模型， fasttext 使用了子空间量化和字典裁剪的策略，在不损失模型精度的情况下，将模型大小缩减数百倍。

在 fasttext 之上，可以做进一步优化，一个方向是在文本分类模型中，文本表达用类似 tf-idf 的方式对词进行加权平均。在字典裁剪算法上，一个涵盖所有文本的词并不一定有区分能力，比如 "the" 这个单词，可以尝试从保留区分能力的视角来保留字典。

七. 引用

[1] https://github.com/facebookresearch/fastText
[2] Bojanowski, Piotr and Grave, Edouard and Joulin, Armand and Mikolov, Tomas. "Enriching Word Vectors with Subword Information".
[3] Joulin, Armand and Grave, Edouard and Bojanowski, Piotr and Mikolov, Tomas. "Bag of Tricks for Efficient Text Classification".
[4]Joulin, Armand and Grave, Edouard and Bojanowski, Piotr and Douze, Matthijs and Jegou, Herve and Mikolov, Tomas. "FastText.zip: Compressing text classification models".
[5] Mikolov, Tomas, et al. "Efficient Estimation of Word Representations in Vector Space".
[6] Jeffrey Pennington, Richard Socher, and Christopher D. Manning. 2014. "GloVe: Global Vectors for Word Representation".
[7] Xinxiong Chen, Lei Xu, Zhiyuan Liu, Maosong Sun, and Huanbo Luan. 2015. Joint learning of character and word embeddings. In Proc. IJCAI.
[8] Product quantization for nearest neighbor search. H Jegou, M Douze, C Schmid. IEEE Transactions on Pattern Analysis and Machine Intelligence
[9] https://dumps.wikimedia.org/zhwiki/
[10] https://github.com/facebookresearch/fastText/blob/master/pretrained-vectors.md

作者：machinelearning
链接：https://www.jianshu.com/p/9ea0d69dd55e
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

转载于:https://www.cnblogs.com/ExMan/p/9858350.html

weixin_30897079

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
FastText 分析与实践

一. 前言自然语言处理(NLP)是机器学习，人工智能中的一个重要领域。文本表达是 NLP中的基础技术，文本分类则是 NLP 的重要应用。在 2016 年， Facebook Research 开源了名为 fasttext[1] 的文本表达和分类的计算库。 fasttext 是基于文章 [2], [3], [4] 所提出算法的实现，针对变形词汇表达，线性分类优化提供了优秀的解决方案。本...
复制链接

扫一扫