【一】關於fasttext

fasttext是Facebook開源的一個工具包，用於詞向量訓練和文字分類。該工具包使用C++11編寫，全部使用C++11 STL（這裡主要是thread庫），不依賴任何第三方庫。具體使用方法見：https://fasttext.cc/ ，在Linux 使用非常方便。fasttext不僅提供了軟體原始碼，還提供了訓練好的一些模型（多語種的詞向量：英文、中文等150餘種）

原始碼地址：https://github.com/facebookresearch/fastText/

gensim也對該功能進行了封裝，可以直接使用。

fasttext的原始碼實現非常優雅，分析原始碼，帶來以下幾方面的收穫：

1. 如何組織文字資料？

2. CBOW和skip-gram是如何實現的？

3. 模型如何量化？

【二】fasttext整體結構

【三】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是一個很好的工具，但要訓練出一個合適的模型，需要對模型的引數有所理解，然而一般情況下，預設的引數就能滿足要求了。