FastText: कोड नुस्खा

शुभ दिन, दोस्तों! मैं आपके लिए मूल लेख का एक शौकिया अनुवाद प्रस्तुत करता हूं: फास्टटेक्स्ट: मारिया मेस्ट्रे द्वारा कोड के माध्यम से कदम ।

एक छोटी सी चेतावनी: उपलब्ध कराई गई कुछ जानकारी लेखक के समय और यादृच्छिक त्रुटियों के पारित होने के कारण पूरी तरह से सच नहीं हो सकती है। किसी भी मामले में, कोई भी प्रतिक्रिया वांछनीय होगी!

आपने ग्रंथों के अपने शरीर को वेक्टर करने के लिए FastText जैसे उपकरण का सामना किया होगा, लेकिन क्या आप जानते हैं कि FastText आपके वर्गीकरण से भी निपट सकता है? या शायद वे जानते थे, लेकिन क्या वह जानता है कि वह इसे कैसे करता है? चलो इसे अंदर से देखें ... मेरा मतलब है, स्क्रीन के माध्यम से।

FastText पुस्तकालय मुख्य रूप से फेसबुक टीम द्वारा ग्रंथों को वर्गीकृत करने के लिए विकसित किया गया था, लेकिन इसका उपयोग शब्द एम्बेडिंग को प्रशिक्षित करने के लिए भी किया जा सकता है। चूंकि उस समय जब फास्टटेक्स सभी के लिए सुलभ उत्पाद बन गया (2016), इसका उपयोग इसकी अच्छी प्रशिक्षण गति और उत्कृष्ट प्रदर्शन के कारण व्यापक रूप से किया गया है।

आधिकारिक प्रलेखन (स्पष्टीकरण के लिए बहुत ही दुर्लभ) को पढ़ते हुए, मुझे एहसास हुआ कि इसमें एल्गोरिदम का एक बड़ा हिस्सा शामिल है जो पूरी तरह से पारदर्शी नहीं हो सकता है, इसलिए यह स्वतंत्र रूप से यह पता लगाने का निर्णय लिया गया था कि यह कैसे काम करता है और यह क्या खाता है। मैंने रचनाकारों के मुख्य लेख और एनएलपी में स्टैनफोर्ड डीप लर्निंग कोर्स पर एक त्वरित नज़र डालकर पढ़ना शुरू किया। इस सारी खुशी की प्रक्रिया में, मैंने केवल प्रश्न बढ़ाए। उदाहरण के लिए: कि स्टैनफोर्ड के व्याख्यान के दौरान और लेख के एक हिस्से में वे एन-ग्राम के उपयोग के बारे में बात करते हैं, लेकिन वे अपने आवेदन में कोई विशेषताएं नहीं कहते हैं। इसके अलावा, कमांड लाइन में निर्दिष्ट मापदंडों में एक निश्चित बाल्टी ही शामिल है जिस पर केवल "कंटेनर (बाल्टी) की संख्या" जैसी ध्वनि होती है। इन एन-ग्रामों की गणना कैसे की जाती है? बाल्टी? यह स्पष्ट नहीं है ... एक विकल्प शेष है, कोड देखेंGitHub ।

सभी अच्छे को देखने के बाद, निम्नलिखित पता चला

• फास्टटेक्स्ट आत्मविश्वास के साथ एन-ग्राम अक्षरों का उपयोग करता है जो कि एन-ग्राम शब्दों के समान ही है।
• फास्टटेक्स्ट मल्टीस्केल्स वर्गीकरण का समर्थन करता है, जो पहली बार इतना स्पष्ट नहीं हो सकता है।
• मॉडल मापदंडों की संख्या

मॉडल परिचय

डेवलपर्स द्वारा लिखे गए एक लेख के अनुसार, मॉडल एक छिपी हुई परत के साथ एक सरल तंत्रिका नेटवर्क है। शब्द बैग (BOW) द्वारा दर्शाया गया पाठ पहली परत से होकर गुजरा है जिसमें यह शब्द एम्बेड में बदल जाता है। इसके बाद, परिणामी एम्बेडिंग पूरे पाठ पर औसतन होती है और पूरे पाठ में लागू होने वाले केवल एक के लिए कम हो जाती है। छिपी हुई परत में, हम मापदंडों की संख्या द्वारा n_words * मंद के साथ काम करते हैं , जहां मंद एम्बेडिंग का आकार है, और n_words पाठ के लिए उपयोग किए जाने वाले शब्दकोश का आकार है। औसत के बाद, हमें एक एकल वेक्टर मिलता है जो एक लोकप्रिय क्लासिफायरिफायर से गुजरता है: सॉफ्टमैक्स फ़ंक्शन का उपयोग किया जाता हैपहली परत के इनपुट डेटा के रैखिक मैपिंग (रूपांतरण) के लिए अंतिम। आयाम मंद का एक मैट्रिक्स * n_output एक रैखिक परिवर्तन के रूप में कार्य करता है , जहां n_output हमारी वास्तविक कक्षाओं की संख्या है। मूल लेख में, अंतिम संभावना को लॉग-संभावना के रूप में माना जाता है :



जहां:

• x_n n-gram में एक शब्द का प्रतिनिधित्व है।
• और यह एक लुक_अप मैट्रिक्स है जो किसी शब्द के एम्बेडिंग को निकालता है।
• यह आउटपुट का एक रैखिक परिवर्तन है।
• f सीधे सॉफ्टमैक्स फ़ंक्शन को स्वयं करता है।

सामान्य तौर पर सब कुछ इतना बुरा नहीं है, लेकिन फिर भी आइए कोड पर एक नज़र डालते हैं:

एक विचार अनुवाद के रूप में कोड

स्रोत डेटा के साथ फ़ाइल जिसे हम अपने क्लासिफ़ायर के लिए आवेदन कर सकते हैं, उसे एक विशिष्ट फ़ॉर्म का पालन करना चाहिए: __label__0 (पाठ)।

उदाहरण के रूप में:
__label__cat यह चोरी बिल्लियों के बारे में है।
__label__dog यह पाठ कुत्तों के बारे में है।

स्रोत फ़ाइल का उपयोग ट्रेन फ़ंक्शन के तर्क के रूप में किया जाता है । ट्रेन फ़ंक्शन प्रारंभ और बाद में डिक्ट्री_ वेरिएबल के भरने से शुरू होता है ।

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!");
  }
  dict_->readFromFile(ifs);

डिक्शनरी_ डिक्शनरी क्लास का एक उदाहरण है।

Dictionary::Dictionary(std::shared_ptr<Args> args) : args_(args),
  word2int_(MAX_VOCAB_SIZE, -1), size_(0), nwords_(0), nlabels_(0),
  ntokens_(0), pruneidx_size_(-1) {}

स्रोत फ़ाइल के वाक्यों को पढ़ने और पार्स करने के बाद, हम दो वैक्टर भरते हैं:

• शब्द_ जिसमें पाठ से निकाले गए अद्वितीय शब्द हैं
• word2int_ में अपनी स्थिति के अनुसार प्रत्येक शब्द के लिए हैश युक्त words_ वेक्टर । यह वास्तव में बहुत महत्वपूर्ण है, क्योंकि यह निर्धारित करता है कि मैट्रिक्स ए के एम्बेडिंग के लिए खोज करने के लिए उपयोग किया जाएगा

शब्द_ वेक्टर में प्रविष्टि के उदाहरण हैं। जिनमें से प्रत्येक लेबल के लिए एक शब्द प्रकार हो सकता है और उनके पास कॉल का एक काउंटर हो सकता है। एक उप- फ़ील्ड फ़ील्ड भी है , लेकिन हम इसे थोड़ा आगे देखेंगे।

struct entry {
  std::string word;
  int64_t count;
  entry_type type;
  std::vector<int32_t> subwords;
};

शब्द या टैग को शब्द 2int_ चर में जोड़कर , टकराव को इस तरह से हल किया जाता है कि हम कभी भी दो अलग-अलग शब्दों को संदर्भित नहीं करते हैं जिनमें एक ही सूचकांक होता है। वहाँ बस कोई नहीं होगा

int32_t Dictionary::find(const std::string& w, uint32_t h) const {
  int32_t word2intsize = word2int_.size();
  int32_t id = h % word2intsize;
  while (word2int_[id] != -1 && words_[word2int_[id]].word != w) {
    id = (id + 1) % word2intsize;
  }
  return id;
}

int32_t Dictionary::find(const std::string& w) const {
  return find(w, hash(w));
}

void Dictionary::add(const std::string& w) {
  int32_t h = find(w);
  ntokens_++;
  if (word2int_[h] == -1) {
    entry e;
    e.word = w;
    e.count = 1;
    e.type = getType(w);
    words_.push_back(e);
    word2int_[h] = size_++;
  } else {
    words_[word2int_[h]].count++;
  }
}

दोनों वैक्टर को यह सुनिश्चित करने के लिए फ़िल्टर किया जाता है कि कम से कम एक बार उल्लेखित शब्द और टैग शामिल हैं। हम उस हिस्से पर जाने के बाद जहां हम रीडफ्रॉमफाइल फ़ंक्शन का उपयोग करते हैं जहां initNgrams कहा जाता है । हम लगभग एन-ग्राम का उपयोग करने के रहस्यवादी के पास गए।

void Dictionary::readFromFile(std::istream& in) {
  std::string word;
  int64_t minThreshold = 1;
  while (readWord(in, word)) {
    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();
  initNgrams();

InitNgrams फ़ंक्शन एन-ग्राम वर्णों के सभी संयोजनों को परिभाषित करता है और उन्हें एनग्राम वेक्टर में जोड़ता है । अंत में, एन-ग्राम के लिए सभी हैश की गणना की जाती है और एनग्राम वेक्टर में जोड़ा जाता है , जिससे बाल्टी का आकार बनता है । दूसरे शब्दों में, एन-ग्राम के वर्णों के हैश को एन-ग्राम शब्दों के हैश को जोड़ने के बाद जोड़ा जाता है। नतीजतन, उनके सूचकांक शब्दों के सूचकांकों के साथ ओवरलैप नहीं होते हैं, लेकिन एक दूसरे के साथ ओवरलैप हो सकते हैं।

सामान्य तौर पर, पाठ के प्रत्येक शब्द के लिए, आप सब - पासवर्ड ... एन-ग्राम वर्ण प्रदान कर सकते हैं ।
एंबेडिंग मैट्रिक्स A निम्नलिखित प्रदर्शित करता है:

• पाठ के लिए उपलब्ध शब्दकोश से प्रत्येक शब्द के लिए प्रारंभिक nwords_ लाइनें जिनमें एम्बेडिंग है।
• प्रत्येक एन-ग्राम के पात्रों के लिए एम्बेडिंग वाली लाइनों की बाल्टी का पालन करें

void Dictionary::initNgrams() {
  for (size_t i = 0; i < size_; i++) {
    std::string word = BOW + words_[i].word + EOW;
    words_[i].subwords.clear();
    words_[i].subwords.push_back(i);
    if (words_[i].word != EOS) {
      computeSubwords(word, words_[i].subwords);
    }
  }
}

void Dictionary::computeSubwords(const std::string& word,
                               std::vector<int32_t>& ngrams) 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++]);
      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;
        pushHash(ngrams, h);
      }
    }
  }
}

void Dictionary::pushHash(std::vector<int32_t>& hashes, int32_t id) const {
  if (pruneidx_size_ == 0 || id < 0) return;
  if (pruneidx_size_ > 0) {
    if (pruneidx_.count(id)) {
      id = pruneidx_.at(id);
    } else {
      return;
    }
  }
  hashes.push_back(nwords_ + id);
}

इसलिए हमने रहस्यमय एन-ग्राम पात्रों का अनुमान लगाया। अब शब्दों के एन-ग्राम से निपटते हैं। ट्रेन

फ़ंक्शन पर लौटते हुए , निम्नलिखित निर्देशों को निष्पादित किया जाता है:

  if (args_->pretrainedVectors.size() != 0) {
    loadVectors(args_->pretrainedVectors);
  } else {
    input_ = std::make_shared<Matrix>(dict_->nwords()+args_->bucket, args_->dim);
    input_->uniform(1.0 / args_->dim);
  }

  if (args_->model == model_name::sup) {
    output_ = std::make_shared<Matrix>(dict_->nlabels(), args_->dim);
  } else {
    output_ = std::make_shared<Matrix>(dict_->nwords(), args_->dim);
  }
  output_->zero();
  startThreads();

यह वह जगह है जहां एम्बेडिंग मैट्रिक्स ए को इनिशियलाइज़ किया गया है। यह इंगित किया जाना चाहिए कि अगर pretrainedVectors इस फ़ंक्शन के साथ काम करते हैं, तो यह चर पूर्ण माना जाता है। यदि ऐसा नहीं होता है, तो मैट्रिक्स को यादृच्छिक संख्या -1 / मंद और 1 / मंद के साथ प्रारंभ किया जाता है , जहां मंद हमारे एम्बेडिंग का आकार है। मैट्रिक्स ए का आयाम ( n_words_ + बाल्टी ; मंद ), अर्थात हम प्रत्येक शब्द के लिए ये सभी एम्बेडिंग सेट करने जा रहे हैं। इस चरण में आउटपुट को इनिशियलाइज़ भी किया जाता है।

नतीजतन, हमें वह हिस्सा मिलता है जहां हम अपने मॉडल का प्रशिक्षण शुरू करते हैं।

void FastText::trainThread(int32_t threadId) {
  std::ifstream ifs(args_->input);
  utils::seek(ifs, threadId * utils::size(ifs) / args_->thread);

  Model model(input_, output_, args_, threadId);
  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) {
      localTokenCount += dict_->getLine(ifs, line, model.rng);
      cbow(model, lr, line);
    } else if (args_->model == model_name::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();
}

कोड के इस भाग में दो मुख्य बिंदु हैं। सबसे पहले, getLine फ़ंक्शन डिक्टेड_ वेरिएबल को कॉल करता है । दूसरा, पर्यवेक्षित फ़ंक्शन कहलाता है ।

int32_t Dictionary::getLine(std::istream& in,
                            std::vector<int32_t>& words,
                            std::vector<int32_t>& labels) const {
  std::vector<int32_t> word_hashes;
  std::string token;
  int32_t ntokens = 0;

  reset(in);
  words.clear();
  labels.clear();
  while (readWord(in, token)) {
    uint32_t h = hash(token);
    int32_t wid = getId(token, h);
    entry_type type = wid < 0 ? getType(token) : getType(wid);

    ntokens++;
    if (type == entry_type::word) {
      addSubwords(words, token, wid);
      word_hashes.push_back(h);
    } else if (type == entry_type::label && wid >= 0) {
      labels.push_back(wid - nwords_);
    }<source lang="cpp">
    if (token == EOS) break;
  }
  addWordNgrams(words, word_hashes, args_->wordNgrams);
  return ntokens;
}

उपरोक्त फ़ंक्शन में, हम इनपुट डेटा से ग्रंथों को पढ़ते हैं, प्रत्येक शब्द के लिए सूचक का निर्धारण एक दूसरे के बाद word2int_ का उपयोग करके करते हैं । हम एन-ग्राम जोड़ते हैं जो इन शब्दों को शब्द चर में बनाते हैं , जैसा कि कोड में संकेत दिया गया है। और अंत में, हम सीधे लेबल वेक्टर में लेबल जोड़ते हैं ।

उनके लिए बनाए गए वैक्टर से सीधे पाठ (कॉर्पस से वाक्य) को पूरी तरह से पढ़ने और जोड़ने के बाद, हमें एन-ग्राम को संसाधित करने वाले कोड का एक हिस्सा मिलता है। यह addWordNgrams फ़ंक्शन है ।

void Dictionary::addWordNgrams(std::vector<int32_t>& line,
                               const std::vector<int32_t>& hashes,
                               int32_t n) const {
  for (int32_t i = 0; i < hashes.size(); i++) {
    uint64_t h = hashes[i];
    for (int32_t j = i + 1; j < hashes.size() && j < i + n; j++) {
      h = h * 116049371 + hashes[j];
      pushHash(line, h % args_->bucket);
    }
  }
}

हम आगे देखते हैं। हैश चर पाठ में प्रत्येक शब्द के लिए हैश का एक सेट है, जहां लाइन में वाक्य में शब्दों की संख्या और उपयोग किए गए एन-ग्राम की संख्या होती है। पैरामीटर n पैरामीटर शब्दNgrams है और शब्दों के एन-ग्राम की अधिकतम लंबाई को इंगित करता है। शब्दों के प्रत्येक एन-ग्राम को अपने स्वयं के हैश की गणना एक पुनरावर्ती सूत्र द्वारा की जाती है

$$

$$h = h*116049371+hashes[j]$$

। यह सूत्र एक स्ट्रिंग के लिए लागू FNV हैश एल्गोरिथ्म है: यह शब्दों के एन-ग्राम में प्रत्येक शब्द का हैश लेता है और उन्हें जोड़ता है। इस प्रकार, अद्वितीय हैश का एक सेट प्राप्त किया जाता है। नतीजतन, यह मान (काफी बड़ा हो सकता है) मॉडुलो प्रसारित होता है।

इस प्रकार, एन-ग्राम शब्दों की गणना लगभग उसी तरह से की जाती है जैसे कि एन-ग्राम वर्ण, लेकिन थोड़े अंतर के साथ - हमारे पास एक विशिष्ट शब्द नहीं है। कमाल की चाल है।

वाक्य पढ़ने के बाद, पर्यवेक्षित फ़ंक्शन कहा जाता है । यदि ऑफ़र में कई टैग हैं, तो हम बेतरतीब ढंग से उनमें से एक का चयन करते हैं।

void FastText::supervised(
    Model& model,
    real lr,
    const std::vector<int32_t>& line,
    const std::vector<int32_t>& labels) {
  if (labels.size() == 0 || line.size() == 0) return;
  std::uniform_int_distribution<> uniform(0, labels.size() - 1);
  int32_t i = uniform(model.rng);
  model.update(line, labels[i], lr);
}

और अंत में, मॉडल अपडेट फ़ंक्शन।

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_) {
      hidden.addRow(*qwi_, *it);
    } else {
      hidden.addRow(*wi_, *it);
    }
  }
  hidden.mul(1.0 / input.size());
}

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_);
  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);
  }
}

पर्यवेक्षित फ़ंक्शन से गुजरने वाले इनपुट चर में वाक्य के उनके सभी घटकों (शब्दों, शब्दों के एन-ग्राम और प्रतीकों) के सूचकांकों की एक सूची होती है। लक्ष्य एक वर्ग को आउटपुट पर परिभाषित करना है। कम्प्यूटेड फ़ंक्शन इनपुट के प्रत्येक घटक के लिए wi_ मैट्रिक्स में उन्हें खोजकर और औसत ( addRow को उनके आकार से विभाजित और विभाजित किया गया है) के लिए सभी एम्बेडिंग निर्धारित करता है । Hide_ वेक्टर को संशोधित करने के बाद , उन्हें सॉफ्टमैक्स के माध्यम से सक्रियण के लिए भेजें और एक लेबल परिभाषित करें।

कोड का यह खंड सॉफ्टमैक्स सक्रियण फ़ंक्शन का उपयोग दिखाता है । लॉग-लॉस की गणना भी की जाती है ।

void Model::computeOutputSoftmax(Vector& hidden, Vector& output) const {
  if (quant_ && args_->qout) {
    output.mul(*qwo_, hidden);
  } else {
    output.mul(*wo_, hidden);
  }
  real max = output[0], z = 0.0;
  for (int32_t i = 0; i < osz_; i++) {
    max = std::max(output[i], max);
  }
  for (int32_t i = 0; i < osz_; i++) {
    output[i] = exp(output[i] - max);
    z += output[i];
  }
  for (int32_t i = 0; i < osz_; i++) {
    output[i] /= z;
  }
}

void Model::computeOutputSoftmax() {
  computeOutputSoftmax(hidden_, output_);
}

real Model::softmax(int32_t target, real lr) {
  grad_.zero();
  computeOutputSoftmax();
  for (int32_t i = 0; i < osz_; i++) {
    real label = (i == target) ? 1.0 : 0.0;
    real alpha = lr * (label - output_[i]);
    grad_.addRow(*wo_, i, alpha);
    wo_->addRow(hidden_, i, alpha);
  }
  return -log(output_[target]);
}

इस पद्धति के उपयोग से, हमें शब्दों और वर्णों के एन-ग्राम के आकार में वृद्धि नहीं मिलेगी। विकास पहले से उपलब्ध बाल्टियों की संख्या से सीमित है ।

डिफ़ॉल्ट रूप से, FastText N-gr का उपयोग नहीं करता है, लेकिन हम निम्नलिखित विकल्पों की सलाह देते हैं:

• हिरन = 2,000,000; शब्दग्राम> 1 या अधिकतम> 0
• मंद = १००
• n_output = 2
• n_words = 500000

कुल मिलाकर, हमें प्रशिक्षण के लिए काफी बड़ी संख्या में पैरामीटर मिलते हैं

$$

$$(5000000+2000000)*100+(2*100) = 250,000,000$$

बहुत अधिक, यह नहीं है?) जैसा कि हम इस तरह के एक सरल दृष्टिकोण के माध्यम से भी देख सकते हैं, हमारे पास काफी बड़ी संख्या में पैरामीटर हैं, जो कि गहन शिक्षण विधियों की बहुत विशिष्ट है। उदाहरण के लिए, क्रम दिखाने के लिए 2_000_000 के लिए ली गई N-gr की संख्या का उपयोग किया जाता है। सामान्य तौर पर, कुछ हाइपरपरमेटर्स, जैसे बाल्टी या सैंपलिंग थ्रेशोल्ड को ट्यून करके मॉडल की जटिलता को कम किया जा सकता है।

कुछ लिंक उपयोगी हो सकते हैं:
research.fb.com/fasttext
arxiv.org/pdf/1607.01759.pdf और arxiv.org/pdf/1607.04606v1.pdf
www.youtube.com/watch?v=isPiE-DBagM&index=5&list=PLU40WLOO894/zp94 (47:39 से)