fasttext 0.1.2 → 0.2.2

data/vendor/fastText/src/meter.cc

@@ -16,6 +16,9 @@
 
 namespace fasttext {
 
+constexpr int32_t kAllLabels = -1;
+constexpr real falseNegativeScore = -1.0;
+
 void Meter::log(
     const std::vector<int32_t>& labels,
     const Predictions& predictions) {
@@ -26,14 +29,23 @@ void Meter::log(
   for (const auto& prediction : predictions) {
     labelMetrics_[prediction.second].predicted++;
 
+    real score = std::min(std::exp(prediction.first), 1.0f);
+    real gold = 0.0;
     if (utils::contains(labels, prediction.second)) {
       labelMetrics_[prediction.second].predictedGold++;
       metrics_.predictedGold++;
+      gold = 1.0;
     }
+    labelMetrics_[prediction.second].scoreVsTrue.emplace_back(score, gold);
   }
 
-  for (const auto& label : labels) {
-    labelMetrics_[label].gold++;
+  if (falseNegativeLabels_) {
+    for (const auto& label : labels) {
+      labelMetrics_[label].gold++;
+      if (!utils::containsSecond(predictions, label)) {
+        labelMetrics_[label].scoreVsTrue.emplace_back(falseNegativeScore, 1.0);
+      }
+    }
   }
 }
 
@@ -57,6 +69,15 @@ double Meter::recall() const {
   return metrics_.recall();
 }
 
+double Meter::f1Score() const {
+  const double precision = this->precision();
+  const double recall = this->recall();
+  if (precision + recall != 0) {
+    return 2 * precision * recall / (precision + recall);
+  }
+  return std::numeric_limits<double>::quiet_NaN();
+}
+
 void Meter::writeGeneralMetrics(std::ostream& out, int32_t k) const {
   out << "N"
       << "\t" << nexamples_ << std::endl;
@@ -65,4 +86,129 @@ void Meter::writeGeneralMetrics(std::ostream& out, int32_t k) const {
   out << "R@" << k << "\t" << metrics_.recall() << std::endl;
 }
 
+std::vector<std::pair<uint64_t, uint64_t>> Meter::getPositiveCounts(
+    int32_t labelId) const {
+  std::vector<std::pair<uint64_t, uint64_t>> positiveCounts;
+
+  const auto& v = scoreVsTrue(labelId);
+  uint64_t truePositives = 0;
+  uint64_t falsePositives = 0;
+  double lastScore = falseNegativeScore - 1.0;
+
+  for (auto it = v.rbegin(); it != v.rend(); ++it) {
+    double score = it->first;
+    double gold = it->second;
+    if (score < 0) { // only reachable recall
+      break;
+    }
+    if (gold == 1.0) {
+      truePositives++;
+    } else {
+      falsePositives++;
+    }
+    if (score == lastScore && positiveCounts.size()) { // squeeze tied scores
+      positiveCounts.back() = {truePositives, falsePositives};
+    } else {
+      positiveCounts.emplace_back(truePositives, falsePositives);
+    }
+    lastScore = score;
+  }
+
+  return positiveCounts;
+}
+
+double Meter::precisionAtRecall(double recallQuery) const {
+  return precisionAtRecall(kAllLabels, recallQuery);
+}
+
+double Meter::precisionAtRecall(int32_t labelId, double recallQuery) const {
+  const auto& precisionRecall = precisionRecallCurve(labelId);
+  double bestPrecision = 0.0;
+  std::for_each(
+      precisionRecall.begin(),
+      precisionRecall.end(),
+      [&bestPrecision, recallQuery](const std::pair<double, double>& element) {
+        if (element.second >= recallQuery) {
+          bestPrecision = std::max(bestPrecision, element.first);
+        };
+      });
+  return bestPrecision;
+}
+
+double Meter::recallAtPrecision(double precisionQuery) const {
+  return recallAtPrecision(kAllLabels, precisionQuery);
+}
+
+double Meter::recallAtPrecision(int32_t labelId, double precisionQuery) const {
+  const auto& precisionRecall = precisionRecallCurve(labelId);
+  double bestRecall = 0.0;
+  std::for_each(
+      precisionRecall.begin(),
+      precisionRecall.end(),
+      [&bestRecall, precisionQuery](const std::pair<double, double>& element) {
+        if (element.first >= precisionQuery) {
+          bestRecall = std::max(bestRecall, element.second);
+        };
+      });
+  return bestRecall;
+}
+
+std::vector<std::pair<double, double>> Meter::precisionRecallCurve() const {
+  return precisionRecallCurve(kAllLabels);
+}
+
+std::vector<std::pair<double, double>> Meter::precisionRecallCurve(
+    int32_t labelId) const {
+  std::vector<std::pair<double, double>> precisionRecallCurve;
+  const auto& positiveCounts = getPositiveCounts(labelId);
+  if (positiveCounts.empty()) {
+    return precisionRecallCurve;
+  }
+
+  uint64_t golds =
+      (labelId == kAllLabels) ? metrics_.gold : labelMetrics_.at(labelId).gold;
+
+  auto fullRecall = std::lower_bound(
+      positiveCounts.begin(),
+      positiveCounts.end(),
+      golds,
+      utils::compareFirstLess);
+
+  if (fullRecall != positiveCounts.end()) {
+    fullRecall = std::next(fullRecall);
+  }
+
+  for (auto it = positiveCounts.begin(); it != fullRecall; it++) {
+    double precision = 0.0;
+    double truePositives = it->first;
+    double falsePositives = it->second;
+    if (truePositives + falsePositives != 0.0) {
+      precision = truePositives / (truePositives + falsePositives);
+    }
+    double recall = golds != 0 ? (truePositives / double(golds))
+                               : std::numeric_limits<double>::quiet_NaN();
+    precisionRecallCurve.emplace_back(precision, recall);
+  }
+  precisionRecallCurve.emplace_back(1.0, 0.0);
+
+  return precisionRecallCurve;
+}
+
+std::vector<std::pair<real, real>> Meter::scoreVsTrue(int32_t labelId) const {
+  std::vector<std::pair<real, real>> ret;
+  if (labelId == kAllLabels) {
+    for (const auto& k : labelMetrics_) {
+      auto& labelScoreVsTrue = labelMetrics_.at(k.first).scoreVsTrue;
+      ret.insert(ret.end(), labelScoreVsTrue.begin(), labelScoreVsTrue.end());
+    }
+  } else {
+    if (labelMetrics_.count(labelId)) {
+      ret = labelMetrics_.at(labelId).scoreVsTrue;
+    }
+  }
+  sort(ret.begin(), ret.end());
+
+  return ret;
+}
+
 } // namespace fasttext

data/vendor/fastText/src/meter.h

@@ -22,8 +22,9 @@ class Meter {
     uint64_t gold;
     uint64_t predicted;
     uint64_t predictedGold;
+    mutable std::vector<std::pair<real, real>> scoreVsTrue;
 
-    Metrics() : gold(0), predicted(0), predictedGold(0) {}
+    Metrics() : gold(0), predicted(0), predictedGold(0), scoreVsTrue() {}
 
     double precision() const {
       if (predicted == 0) {
@@ -43,18 +44,38 @@ class Meter {
       }
       return 2 * predictedGold / double(predicted + gold);
     }
+
+    std::vector<std::pair<real, real>> getScoreVsTrue() {
+      return scoreVsTrue;
+    }
   };
+  std::vector<std::pair<uint64_t, uint64_t>> getPositiveCounts(
+      int32_t labelId) const;
 
  public:
-  Meter() : metrics_(), nexamples_(0), labelMetrics_() {}
+  Meter() = delete;
+  explicit Meter(bool falseNegativeLabels)
+      : metrics_(),
+        nexamples_(0),
+        labelMetrics_(),
+        falseNegativeLabels_(falseNegativeLabels) {}
 
   void log(const std::vector<int32_t>& labels, const Predictions& predictions);
 
   double precision(int32_t);
   double recall(int32_t);
   double f1Score(int32_t);
+  std::vector<std::pair<real, real>> scoreVsTrue(int32_t labelId) const;
+  double precisionAtRecall(int32_t labelId, double recall) const;
+  double precisionAtRecall(double recall) const;
+  double recallAtPrecision(int32_t labelId, double recall) const;
+  double recallAtPrecision(double recall) const;
+  std::vector<std::pair<double, double>> precisionRecallCurve(
+      int32_t labelId) const;
+  std::vector<std::pair<double, double>> precisionRecallCurve() const;
   double precision() const;
   double recall() const;
+  double f1Score() const;
   uint64_t nexamples() const {
     return nexamples_;
   }
@@ -64,6 +85,7 @@ class Meter {
   Metrics metrics_{};
   uint64_t nexamples_;
   std::unordered_map<int32_t, Metrics> labelMetrics_;
+  bool falseNegativeLabels_;
 };
 
 } // namespace fasttext

data/vendor/fastText/src/model.cc

@@ -10,7 +10,6 @@
 #include "loss.h"
 #include "utils.h"
 
-#include <assert.h>
 #include <algorithm>
 #include <stdexcept>
 

data/vendor/fastText/src/real.h

@@ -11,5 +11,4 @@
 namespace fasttext {
 
 typedef float real;
-
 }

data/vendor/fastText/src/utils.cc

@@ -8,6 +8,7 @@
 
 #include "utils.h"
 
+#include <iomanip>
 #include <ios>
 
 namespace fasttext {
@@ -23,6 +24,30 @@ void seek(std::ifstream& ifs, int64_t pos) {
   ifs.clear();
   ifs.seekg(std::streampos(pos));
 }
+
+double getDuration(
+    const std::chrono::steady_clock::time_point& start,
+    const std::chrono::steady_clock::time_point& end) {
+  return std::chrono::duration_cast<std::chrono::duration<double>>(end - start)
+      .count();
+}
+
+ClockPrint::ClockPrint(int32_t duration) : duration_(duration) {}
+
+std::ostream& operator<<(std::ostream& out, const ClockPrint& me) {
+  int32_t etah = me.duration_ / 3600;
+  int32_t etam = (me.duration_ % 3600) / 60;
+  int32_t etas = (me.duration_ % 3600) % 60;
+
+  out << std::setw(3) << etah << "h" << std::setw(2) << etam << "m";
+  out << std::setw(2) << etas << "s";
+  return out;
+}
+
+bool compareFirstLess(const std::pair<double, double>& l, const double& r) {
+  return l.first < r;
+}
+
 } // namespace utils
 
 } // namespace fasttext

data/vendor/fastText/src/utils.h

@@ -11,7 +11,9 @@
 #include "real.h"
 
 #include <algorithm>
+#include <chrono>
 #include <fstream>
+#include <ostream>
 #include <vector>
 
 #if defined(__clang__) || defined(__GNUC__)
@@ -38,6 +40,33 @@ bool contains(const std::vector<T>& container, const T& value) {
       container.end();
 }
 
+template <typename T1, typename T2>
+bool containsSecond(
+    const std::vector<std::pair<T1, T2>>& container,
+    const T2& value) {
+  return std::find_if(
+             container.begin(),
+             container.end(),
+             [&value](const std::pair<T1, T2>& item) {
+               return item.second == value;
+             }) != container.end();
+}
+
+double getDuration(
+    const std::chrono::steady_clock::time_point& start,
+    const std::chrono::steady_clock::time_point& end);
+
+class ClockPrint {
+ public:
+  explicit ClockPrint(int32_t duration);
+  friend std::ostream& operator<<(std::ostream& out, const ClockPrint& me);
+
+ private:
+  int32_t duration_;
+};
+
+bool compareFirstLess(const std::pair<double, double>& l, const double& r);
+
 } // namespace utils
 
 } // namespace fasttext

data/vendor/fastText/src/vector.cc

@@ -12,7 +12,6 @@
 
 #include <cmath>
 #include <iomanip>
-#include <utility>
 
 #include "matrix.h"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fasttext
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.2
 platform: ruby
 authors:
 - Andrew Kane
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-11 00:00:00.000000000 Z
+date: 2021-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -16,72 +16,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: 4.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-description: 
-email: andrew@chartkick.com
+        version: 4.0.2
+description:
+email: andrew@ankane.org
 executables: []
 extensions:
 - ext/fasttext/extconf.rb
@@ -94,7 +38,6 @@ files:
 - ext/fasttext/extconf.rb
 - lib/fasttext.rb
 - lib/fasttext/classifier.rb
-- lib/fasttext/ext.bundle
 - lib/fasttext/model.rb
 - lib/fasttext/vectorizer.rb
 - lib/fasttext/version.rb
@@ -102,6 +45,8 @@ files:
 - vendor/fastText/README.md
 - vendor/fastText/src/args.cc
 - vendor/fastText/src/args.h
+- vendor/fastText/src/autotune.cc
+- vendor/fastText/src/autotune.h
 - vendor/fastText/src/densematrix.cc
 - vendor/fastText/src/densematrix.h
 - vendor/fastText/src/dictionary.cc
@@ -126,11 +71,11 @@ files:
 - vendor/fastText/src/utils.h
 - vendor/fastText/src/vector.cc
 - vendor/fastText/src/vector.h
-homepage: https://github.com/ankane/fasttext
+homepage: https://github.com/ankane/fastText
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -138,15 +83,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: fastText - efficient text classification and representation learning - for
   Ruby