【一】關於fasttexthtml
fasttext是Facebook開源的一個工具包,用於詞向量訓練和文本分類。該工具包使用C++11編寫,所有使用C++11 STL(這裏主要是thread庫),不依賴任何第三方庫。具體使用方法見:https://fasttext.cc/ ,在Linux 使用很是方便。fasttext不只提供了軟件源碼,還提供了訓練好的一些模型(多語種的詞向量:英文、中文等150餘種)node
源碼地址:https://github.com/facebookresearch/fastText/git
gensim也對該功能進行了封裝,能夠直接使用。github
fasttext的源碼實現很是優雅,分析源碼,帶來如下幾方面的收穫:算法
1. 如何組織文本數據?工具
2. CBOW和skip-gram是如何實現的?源碼分析
3. 模型如何量化?學習
【二】fasttext總體結構ui
【三】fasttext參數配置編碼
主要參數以下:
具體參數使用能夠參考:https://fasttext.cc/docs/en/support.html
【四】dict相關源碼分析
1. 從輸入數據構造詞典的總體流程
void Dictionary::readFromFile(std::istream& in) { std::string word; int64_t minThreshold = 1; // 1. 逐詞讀取 while (readWord(in, word)) { // 2. 將詞添加到詞典中 add(word); if (ntokens_ % 1000000 == 0 && args_->verbose > 1) { std::cerr << "\rRead " << ntokens_ / 1000000 << "M words" << std::flush; } // 若是超出詞典容量,則去除低頻詞 if (size_ > 0.75 * MAX_VOCAB_SIZE) { minThreshold++; // 去除低頻詞 threshold(minThreshold, minThreshold); } } // 去除低頻詞,並按照詞頻降序排序 threshold(args_->minCount, args_->minCountLabel); initTableDiscard(); // 基於n-gram,初始化sub-word initNgrams(); if (args_->verbose > 0) { std::cerr << "\rRead " << ntokens_ / 1000000 << "M words" << std::endl; std::cerr << "Number of words: " << nwords_ << std::endl; std::cerr << "Number of labels: " << nlabels_ << std::endl; } if (size_ == 0) { throw std::invalid_argument( "Empty vocabulary. Try a smaller -minCount value."); } }
2. 面對不一樣的語言,如何讀取一個詞?
// 1. 對於詞向量訓練,須要先分詞,而後詞以前用空格隔開 bool Dictionary::readWord(std::istream& in, std::string& word) const { int c; // 1. 獲取文件流的data指針 std::streambuf& sb = *in.rdbuf(); word.clear(); // 2. 循環讀取,每次從文件流中讀取一個char while ((c = sb.sbumpc()) != EOF) { // 3. 對c讀取的字符作不一樣的處理,若是不是空格等,則繼續讀取下一個字符 if (c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\v' || c == '\f' || c == '\0') { if (word.empty()) { if (c == '\n') { word += EOS; return true; } continue; } else { if (c == '\n') sb.sungetc(); return true; } } // 4. 將char添加到word中,繼續讀取下一個字符 word.push_back(c); } // trigger eofbit in.get(); return !word.empty(); }
3. 如何將一個詞添加到詞典中?
void Dictionary::add(const std::string& w) { // 1. 經過find獲取詞的hash值 int32_t h = find(w); ntokens_++; // 2. 經過hash值,查詢該詞是否在表word2int_中。 // 該表的下標爲詞的hash值,value爲詞的id,容量爲 MAX_VOCAB_SIZE if (word2int_[h] == -1) { // 3. 新詞,將其添加到詞典 words_中 entry e; e.word = w; e.count = 1; // 新詞,詞頻爲1 e.type = getType(w); // 詞的類型,分類則爲label,詞向量則爲word,即將全部的詞放在一個詞典中的 // 沒有分開存儲label與word words_.push_back(e); word2int_[h] = size_++; // 添加詞的id,id就是個順序值,和普通的for循環中的i做爲id是同樣的 } else { // 詞典中已存在的詞,僅增長詞頻 words_[word2int_[h]].count++; } }
4. 如何去低頻詞?
void Dictionary::threshold(int64_t t, int64_t tl) { // 1. 先對詞典中的詞按照詞頻排序, sort(words_.begin(), words_.end(), [](const entry& e1, const entry& e2) { if (e1.type != e2.type) { return e1.type < e2.type; } // 詞頻降序排列 return e1.count > e2.count; }); // 2. 將 word 詞頻小於t的刪除,將label詞頻小於t1的刪除 words_.erase( remove_if( words_.begin(), words_.end(), [&](const entry& e) { return (e.type == entry_type::word && e.count < t) || (e.type == entry_type::label && e.count < tl); }), words_.end()); // 3. 詞典容量調整,前面刪除了部分詞。 words_.shrink_to_fit(); // 4. 重置詞典數據 size_ = 0; nwords_ = 0; nlabels_ = 0; std::fill(word2int_.begin(), word2int_.end(), -1); // 將詞典中的數據從新計算id值 for (auto it = words_.begin(); it != words_.end(); ++it) { int32_t h = find(it->word); word2int_[h] = size_++; if (it->type == entry_type::word) { nwords_++; } if (it->type == entry_type::label) { nlabels_++; } } }
5. initTableDiscard
void Dictionary::initTableDiscard() { // 將 大小調整爲詞典大小 pdiscard_.resize(size_); for (size_t i = 0; i < size_; i++) { // 計算機率,詞頻/詞總數 real f = real(words_[i].count) / real(ntokens_); pdiscard_[i] = std::sqrt(args_->t / f) + args_->t / f; } }
6. initNgrams
void Dictionary::initNgrams() { for (size_t i = 0; i < size_; i++) { // 1. 從詞典中獲取一個詞,並給該詞加上"<"與">",例如:北京---->"<北京>" std::string word = BOW + words_[i].word + EOW; words_[i].subwords.clear(); // 該詞的子詞列表,首先添加全詞的id,全詞也算一個子詞 words_[i].subwords.push_back(i); if (words_[i].word != EOS) { // 依據n-gram,計算子詞 computeSubwords(word, words_[i].subwords); } } }
// word ---->原始的詞 // ngrams --->依據n-gram分割出的子詞,出參 // substrings --->默認值爲nullptr void Dictionary::computeSubwords( const std::string& word, std::vector<int32_t>& ngrams, std::vector<std::string>* substrings) const { // 1. 獲取詞的大小,一個詞多是由多個字符組成的 // 例如:word = "<終南山>" for (size_t i = 0; i < word.size(); i++) { std::string ngram; // 2. 這裏是爲了解決utf-8編碼問題 // 參考:https://stackoverflow.com/questions/3911536/utf-8-unicode-whats-with-0xc0-and-0x80 if ((word[i] & 0xC0) == 0x80) { continue; } // args_->maxn --->配置參數,表示n-gram中的n的最大值,默認爲maxn = 6; // args_->minn --->配置參數,表示n-gram中的n的最小值,默認爲minn = 3; // args_->bucket--->配置參數,表示bucket = 2000000; // 進行n-gram切分:例如:終南山---->終南、南山 for (size_t j = i, n = 1; j < word.size() && n <= args_->maxn; n++) { ngram.push_back(word[j++]); while (j < word.size() && (word[j] & 0xC0) == 0x80) { ngram.push_back(word[j++]); } if (n >= args_->minn && !(n == 1 && (i == 0 || j == word.size()))) { int32_t h = hash(ngram) % args_->bucket; // 這裏面會創建一個sub-word的hash索引 pushHash(ngrams, h); if (substrings) { substrings->push_back(ngram); } } } } }
至此,依據數據數據構建詞典的流程已經完成。主要是完成了word的去重、詞頻統計、詞頻排序、基於n-gram的sub-word預處理、word2id等處理。
【五】train流程分析
1. train的主流程
void FastText::train(const Args args) { args_ = std::make_shared<Args>(args); dict_ = std::make_shared<Dictionary>(args_); if (args_->input == "-") { // manage expectations throw std::invalid_argument("Cannot use stdin for training!"); } std::ifstream ifs(args_->input); if (!ifs.is_open()) { throw std::invalid_argument( args_->input + " cannot be opened for training!"); } // 1. 詞典構造 dict_->readFromFile(ifs); ifs.close(); // 2. 若是有與訓練的向量,則加載 if (args_->pretrainedVectors.size() != 0) { loadVectors(args_->pretrainedVectors); } else { // 3. 構造輸入數據矩陣的大小,這裏也就是embidding的大小 // V*m input_ = std::make_shared<Matrix>(dict_->nwords() + args_->bucket, args_->dim); // 初始化詞嵌入矩陣 input_->uniform(1.0 / args_->dim); } if (args_->model == model_name::sup) { // 隱層輸出矩陣大小,分類: n*m,詞向量 V*m output_ = std::make_shared<Matrix>(dict_->nlabels(), args_->dim); } else { output_ = std::make_shared<Matrix>(dict_->nwords(), args_->dim); } output_->zero(); // 啓動計算 startThreads(); model_ = std::make_shared<Model>(input_, output_, args_, 0); if (args_->model == model_name::sup) { model_->setTargetCounts(dict_->getCounts(entry_type::label)); } else { model_->setTargetCounts(dict_->getCounts(entry_type::word)); } }
2. 單線程訓練流程
void FastText::trainThread(int32_t threadId) { std::ifstream ifs(args_->input); // 1. 按照線程數,將輸入數據平均分配給各個線程, // 各個線程之間不存在數據競爭,英雌不須要加鎖 utils::seek(ifs, threadId * utils::size(ifs) / args_->thread); // 2. 初始化一個model Model model(input_, output_, args_, threadId); // 3. setTargetCounts 接口內部會完成tree或者負採樣的數據初始化 if (args_->model == model_name::sup) { model.setTargetCounts(dict_->getCounts(entry_type::label)); } else { model.setTargetCounts(dict_->getCounts(entry_type::word)); } const int64_t ntokens = dict_->ntokens(); int64_t localTokenCount = 0; std::vector<int32_t> line, labels; while (tokenCount_ < args_->epoch * ntokens) { // 計算處理進度,動態調整學習率 real progress = real(tokenCount_) / (args_->epoch * ntokens); real lr = args_->lr * (1.0 - progress); // 每次讀取一行數據,依據模型不一樣,調用不一樣接口處理 if (args_->model == model_name::sup) { // 文本分類 localTokenCount += dict_->getLine(ifs, line, labels); supervised(model, lr, line, labels); } else if (args_->model == model_name::cbow) { // cbow localTokenCount += dict_->getLine(ifs, line, model.rng); cbow(model, lr, line); } else if (args_->model == model_name::sg) { // sg localTokenCount += dict_->getLine(ifs, line, model.rng); skipgram(model, lr, line); } if (localTokenCount > args_->lrUpdateRate) { tokenCount_ += localTokenCount; localTokenCount = 0; if (threadId == 0 && args_->verbose > 1) loss_ = model.getLoss(); } } if (threadId == 0) loss_ = model.getLoss(); ifs.close(); }
3. 層次softmax的tree的構造
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) { // 節點路徑,即從root到label的路徑 // 路徑哈夫曼編碼,即從root到label的路徑的哈夫曼編碼 // 後面會借用這兩個變量,計算loss 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); } }
4. 負採樣
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); }
5. 參數更新
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; } // 1. 計算隱層的輸出值。若是是分類,則是labels_number * 1 // 若是是word2vec,則是V*1 computeHidden(input, hidden_); // 依據模型類型調用不一樣的接口計算loss if (args_->loss == loss_name::ns) { loss_ += negativeSampling(target, lr); } else if (args_->loss == loss_name::hs) { loss_ += hierarchicalSoftmax(target, lr); } 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); } }
具體計算的代碼這裏就不分析了。
【六】總結
其他部分的代碼(如:預測、評估等),這裏就不分析了,順着代碼看就能夠了。fasttext的代碼結構仍是比較簡單的。代碼閱讀的難點在於算法的理解。後續再結合算法,對代碼細節作分析。
fasttext是一個很好的工具,但要訓練出一個合適的模型,須要對模型的參數有所理解,然而通常狀況下,默認的參數就能知足要求了。