tomoto 0.3.0-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84b7f703e20dd5369af9dd0870a060d565cc02b35eeb478fa78d34f5d19fe237
+  data.tar.gz: 9be4d3113323b349c8c35c2b2213fcf9db915c3ef3fabaf41ad64adfb36c5493
+SHA512:
+  metadata.gz: bde892b432153e8053120a2a4ea87f9744ac50ffbfca3b6a35c2994e99ee33eaa77886d833813ada0c511681321d6cd60e23c7e42708bcc31bf2a6575e31454c
+  data.tar.gz: 4ddb6f191713db0d16a2f65080bdc9a8c771a15855579001ffe064c6b6b44cfbe64378df80fe64616b7a12f3110a0e4af53e72367d3677b2e23c6beed744bedc

data/CHANGELOG.md

@@ -0,0 +1,45 @@
+## 0.3.0 (2022-10-03)
+
+- Added precompiled gems for Linux and Mac
+- Updated tomoto to 0.12.3
+- Dropped support for Ruby < 2.7
+
+## 0.2.3 (2021-08-26)
+
+- Updated to Rice 4
+
+## 0.2.2 (2021-08-23)
+
+- Reduced gem size
+
+## 0.2.1 (2021-08-23)
+
+- Added support for unseen documents
+
+## 0.2.0 (2021-05-23)
+
+- Updated tomoto to 0.12.0
+- Dropped support for Ruby < 2.6
+
+## 0.1.4 (2021-03-14)
+
+- Added `docs` method
+- Updated tomoto to 0.10.2
+- Updated `add_doc` to return the index of the document
+
+## 0.1.3 (2020-12-19)
+
+- Updated tomoto to 0.10.0
+
+## 0.1.2 (2020-10-10)
+
+- Added `summary` method
+- Added `parallel` option to `train` method
+
+## 0.1.1 (2020-10-10)
+
+- Added many more models
+
+## 0.1.0 (2020-10-09)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2019, bab2min
+Copyright (c) 2020-2021 Andrew Kane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,162 @@
+# tomoto.rb
+
+:tomato: [tomoto](https://github.com/bab2min/tomotopy) - high performance topic modeling - for Ruby
+
+[![Build Status](https://github.com/ankane/tomoto-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/tomoto-ruby/actions)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem "tomoto"
+```
+
+## Getting Started
+
+Train a model
+
+```ruby
+model = Tomoto::LDA.new(k: 2)
+model.add_doc("text from document one")
+model.add_doc("text from document two")
+model.add_doc("text from document three")
+model.train(100) # iterations
+```
+
+Get the summary
+
+```ruby
+model.summary
+```
+
+Get topic words
+
+```ruby
+model.topic_words
+```
+
+Save the model to a file
+
+```ruby
+model.save("model.bin")
+```
+
+Load the model from a file
+
+```ruby
+model = Tomoto::LDA.load("model.bin")
+```
+
+Get topic probabilities for a document
+
+```ruby
+doc = model.docs[0]
+doc.topics
+```
+
+Get the number of words for each topic
+
+```ruby
+model.count_by_topics
+```
+
+Get the vocab
+
+```ruby
+model.vocabs
+```
+
+Get the log likelihood per word
+
+```ruby
+model.ll_per_word
+```
+
+Perform inference for unseen documents
+
+```ruby
+doc = model.make_doc("unseen doc")
+topic_dist, ll = model.infer(doc)
+```
+
+## Models
+
+Supports:
+
+- Latent Dirichlet Allocation (`LDA`)
+- Labeled LDA (`LLDA`)
+- Partially Labeled LDA (`PLDA`)
+- Supervised LDA (`SLDA`)
+- Dirichlet Multinomial Regression (`DMR`)
+- Generalized Dirichlet Multinomial Regression (`GDMR`)
+- Hierarchical Dirichlet Process (`HDP`)
+- Hierarchical LDA (`HLDA`)
+- Multi Grain LDA (`MGLDA`)
+- Pachinko Allocation (`PA`)
+- Hierarchical PA (`HPA`)
+- Correlated Topic Model (`CT`)
+- Dynamic Topic Model (`DT`)
+
+## API
+
+This library follows the [tomotopy API](https://bab2min.github.io/tomotopy/v0.9.0/en/). There are a few changes to make it more Ruby-like:
+
+- The `get_` prefix has been removed from methods (`topic_words` instead of `get_topic_words`)
+- Methods that return booleans use `?` instead of `is_`  (`live_topic?` instead of `is_live_topic`)
+
+If a method or option you need isn’t supported, feel free to open an issue.
+
+## Examples
+
+- [LDA](examples/lda_basic.rb)
+- [HDP](examples/hdp_basic.rb)
+
+## Tokenization
+
+Documents are tokenized by whitespace by default, or you can perform your own tokenization.
+
+```ruby
+model.add_doc(["tokens", "from", "document", "one"])
+```
+
+## Performance
+
+tomoto uses AVX2, AVX, or SSE2 instructions to increase performance on machines that support it. Check which instruction set architecture it’s using with:
+
+```ruby
+Tomoto.isa
+```
+
+## Parallelism
+
+Choose a [parallelism algorithm](https://bab2min.github.io/tomotopy/v0.9.0/en/#parallel-sampling-algorithms) with:
+
+```ruby
+model.train(parallel: :partition)
+```
+
+Supported values are `:default`, `:none`, `:copy_merge`, and `:partition`.
+
+## History
+
+View the [changelog](https://github.com/ankane/tomoto-ruby/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/tomoto-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/tomoto-ruby/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone --recursive https://github.com/ankane/tomoto-ruby.git
+cd tomoto-ruby
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/ext/tomoto/ct.cpp

@@ -0,0 +1,58 @@
+#include <CT.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_ct(Rice::Module& m) {
+  Rice::define_class_under<tomoto::ICTModel, tomoto::ILDAModel>(m, "CT")
+    .define_singleton_function(
+      "_new",
+      [](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+        tomoto::CTArgs args;
+        args.k = k;
+        args.alpha = {alpha};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::ICTModel::create((tomoto::TermWeight)tw, args);
+      }, Rice::Return().takeOwnership())
+    .define_method(
+      "_correlations",
+      [](tomoto::ICTModel& self, tomoto::Tid topic_id) {
+        return self.getCorrelationTopic(topic_id);
+      })
+    .define_method(
+      "num_beta_sample",
+      [](tomoto::ICTModel& self) {
+        return self.getNumBetaSample();
+      })
+    .define_method(
+      "num_beta_sample=",
+      [](tomoto::ICTModel& self, size_t value) {
+        self.setNumBetaSample(value);
+        return value;
+      })
+    .define_method(
+      "num_tmn_sample",
+      [](tomoto::ICTModel& self) {
+        return self.getNumTMNSample();
+      })
+    .define_method(
+      "num_tmn_sample=",
+      [](tomoto::ICTModel& self, size_t value) {
+        self.setNumTMNSample(value);
+        return value;
+      })
+    .define_method(
+      "_prior_cov",
+      [](tomoto::ICTModel& self) {
+        return self.getPriorCov();
+      })
+    .define_method(
+      "prior_mean",
+      [](tomoto::ICTModel& self) {
+        return self.getPriorMean();
+      });
+}

data/ext/tomoto/dmr.cpp

@@ -0,0 +1,69 @@
+#include <DMR.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_dmr(Rice::Module& m) {
+  Rice::define_class_under<tomoto::IDMRModel, tomoto::ILDAModel>(m, "DMR")
+    .define_singleton_function(
+      "_new",
+      [](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float eta, tomoto::Float alpha_epsilon, size_t seed) {
+        tomoto::DMRArgs args;
+        args.k = k;
+        args.alpha = {alpha};
+        args.sigma = sigma;
+        args.eta = eta;
+        args.alphaEps = alpha_epsilon;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::IDMRModel::create((tomoto::TermWeight)tw, args);
+      }, Rice::Return().takeOwnership())
+    .define_method(
+      "_add_doc",
+      [](tomoto::IDMRModel& self, std::vector<std::string> words, std::string metadata) {
+        auto doc = buildDoc(words);
+        doc.misc["metadata"] = metadata;
+        return self.addDoc(doc);
+      })
+    .define_method(
+      "alpha_epsilon",
+      [](tomoto::IDMRModel& self) {
+        return self.getAlphaEps();
+      })
+    .define_method(
+      "alpha_epsilon=",
+      [](tomoto::IDMRModel& self, tomoto::Float value) {
+        self.setAlphaEps(value);
+        return value;
+      })
+    .define_method(
+      "f",
+      [](tomoto::IDMRModel& self) {
+        return self.getF();
+      })
+    .define_method(
+      "_lambdas",
+      [](tomoto::IDMRModel& self, tomoto::Tid topic_id) {
+        return self.getLambdaByTopic(topic_id);
+      })
+    .define_method(
+      "metadata_dict",
+      [](tomoto::IDMRModel& self) {
+        auto dict = self.getMetadataDict();
+        Array res;
+        auto utf8 = Rice::Class(rb_cEncoding).call("const_get", "UTF_8");
+        for (size_t i = 0; i < dict.size(); i++) {
+          VALUE value = Rice::detail::To_Ruby<std::string>().convert(dict.toWord(i));
+          Object obj(value);
+          res.push(obj.call("force_encoding", utf8));
+        }
+        return res;
+      })
+    .define_method(
+      "sigma",
+      [](tomoto::IDMRModel& self) {
+        return self.getSigma();
+      });
+}

data/ext/tomoto/dt.cpp

@@ -0,0 +1,91 @@
+#include <DT.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_dt(Rice::Module& m) {
+  Rice::define_class_under<tomoto::IDTModel, tomoto::ILDAModel>(m, "DT")
+    .define_singleton_function(
+      "_new",
+      [](size_t tw, size_t k, size_t t, tomoto::Float alphaVar, tomoto::Float etaVar, tomoto::Float phiVar, tomoto::Float shapeA, tomoto::Float shapeB, tomoto::Float shapeC) {
+        // Rice only supports 10 arguments
+        size_t seed = -1;
+        tomoto::DTArgs args;
+        args.k = k;
+        args.t = t;
+        args.alpha = {alphaVar};
+        args.eta = etaVar;
+        args.phi = phiVar;
+        args.shapeA = shapeA;
+        args.shapeB = shapeB;
+        args.shapeC = shapeC;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::IDTModel::create((tomoto::TermWeight)tw, args);
+      }, Rice::Return().takeOwnership())
+    .define_method(
+      "_add_doc",
+      [](tomoto::IDTModel& self, std::vector<std::string> words, uint32_t timepoint) {
+        auto doc = buildDoc(words);
+        doc.misc["timepoint"] = timepoint;
+        return self.addDoc(doc);
+      })
+    .define_method(
+      "alpha",
+      [](tomoto::IDTModel& self) {
+        Array res;
+        for (size_t i = 0; i < self.getK(); i++) {
+          Array res2;
+          for (size_t j = 0; j < self.getT(); j++) {
+            res2.push(self.getAlpha(i, j));
+          }
+          res.push(res2);
+        }
+        return res;
+      })
+    .define_method(
+      "lr_a",
+      [](tomoto::IDTModel& self) {
+        return self.getShapeA();
+      })
+    .define_method(
+      "lr_a=",
+      [](tomoto::IDTModel& self, tomoto::Float value) {
+        self.setShapeA(value);
+        return value;
+      })
+    .define_method(
+      "lr_b",
+      [](tomoto::IDTModel& self) {
+        return self.getShapeB();
+      })
+    .define_method(
+      "lr_b=",
+      [](tomoto::IDTModel& self, tomoto::Float value) {
+        self.setShapeB(value);
+        return value;
+      })
+    .define_method(
+      "lr_c",
+      [](tomoto::IDTModel& self) {
+        return self.getShapeC();
+      })
+    .define_method(
+      "lr_c=",
+      [](tomoto::IDTModel& self, tomoto::Float value) {
+        self.setShapeC(value);
+        return value;
+      })
+    .define_method(
+      "num_docs_by_timepoint",
+      [](tomoto::IDTModel& self) {
+        return self.getNumDocsByT();
+      })
+    .define_method(
+      "num_timepoints",
+      [](tomoto::IDTModel& self) {
+        return self.getT();
+      });
+}

data/ext/tomoto/extconf.rb

@@ -0,0 +1,34 @@
+require "mkmf-rice"
+
+$CXXFLAGS += " -std=c++17 $(optflags) -DEIGEN_MPL2_ONLY"
+
+unless ENV["RUBY_CC_VERSION"]
+  # AVX-512F not support yet
+  # https://github.com/bab2min/tomotopy/issues/188
+  $CXXFLAGS << " " << with_config("optflags", "-march=native -mno-avx512f")
+end
+
+apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
+
+if apple_clang
+  # silence rice warnings
+  $CXXFLAGS += " -Wno-deprecated-declarations"
+else
+  # silence eigen warnings
+  $CXXFLAGS += " -Wno-ignored-attributes -Wno-deprecated-copy"
+end
+
+# silence tomoto warnings
+$CXXFLAGS += " -Wno-unused-variable -Wno-switch"
+
+ext = File.expand_path(".", __dir__)
+tomoto = File.expand_path("../../vendor/tomotopy/src/TopicModel", __dir__)
+eigen = File.expand_path("../../vendor/eigen", __dir__)
+eigen_rand = File.expand_path("../../vendor/EigenRand", __dir__)
+variant = File.expand_path("../../vendor/variant/include", __dir__)
+
+$srcs = Dir["{#{ext},#{tomoto}}/*.cpp"]
+$INCFLAGS += " -I#{tomoto} -I#{eigen} -I#{eigen_rand} -I#{variant}"
+$VPATH << tomoto
+
+create_makefile("tomoto/tomoto")

data/ext/tomoto/gdmr.cpp

@@ -0,0 +1,42 @@
+#include <GDMR.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_gdmr(Rice::Module& m) {
+  Rice::define_class_under<tomoto::IGDMRModel, tomoto::IDMRModel>(m, "GDMR")
+    .define_singleton_function(
+      "_new",
+      [](size_t tw, size_t k, std::vector<uint64_t> degrees, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float sigma0, tomoto::Float eta, tomoto::Float alpha_epsilon, size_t seed) {
+        tomoto::GDMRArgs args;
+        args.k = k;
+        args.degrees = degrees;
+        args.alpha = {alpha};
+        args.sigma = sigma;
+        args.sigma0 = sigma0;
+        args.eta = eta;
+        args.alphaEps = alpha_epsilon;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::IGDMRModel::create((tomoto::TermWeight)tw, args);
+      }, Rice::Return().takeOwnership())
+    .define_method(
+      "_add_doc",
+      [](tomoto::IGDMRModel& self, std::vector<std::string> words, std::vector<tomoto::Float> numeric_metadata) {
+        auto doc = buildDoc(words);
+        doc.misc["numeric_metadata"] = numeric_metadata;
+        return self.addDoc(doc);
+      })
+    .define_method(
+      "degrees",
+      [](tomoto::IGDMRModel& self) {
+        return self.getFs();
+      })
+    .define_method(
+      "sigma0",
+      [](tomoto::IGDMRModel& self) {
+        return self.getSigma0();
+      });
+}

data/ext/tomoto/hdp.cpp

@@ -0,0 +1,47 @@
+#include <HDP.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_hdp(Rice::Module& m) {
+  Rice::define_class_under<tomoto::IHDPModel, tomoto::ILDAModel>(m, "HDP")
+    .define_singleton_function(
+      "_new",
+      [](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, size_t seed) {
+        tomoto::HDPArgs args;
+        args.k = k;
+        args.alpha = {alpha};
+        args.eta = eta;
+        args.gamma = gamma;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::IHDPModel::create((tomoto::TermWeight)tw, args);
+      }, Rice::Return().takeOwnership())
+    .define_method(
+      "alpha",
+      [](tomoto::IHDPModel& self) {
+        return self.getAlpha();
+      })
+    .define_method(
+      "gamma",
+      [](tomoto::IHDPModel& self) {
+        return self.getGamma();
+      })
+    .define_method(
+      "live_k",
+      [](tomoto::IHDPModel& self) {
+        return self.getLiveK();
+      })
+    .define_method(
+      "live_topic?",
+      [](tomoto::IHDPModel& self, size_t tid) {
+        return self.isLiveTopic(tid);
+      })
+    .define_method(
+      "num_tables",
+      [](tomoto::IHDPModel& self) {
+        return self.getTotalTables();
+      });
+}

data/ext/tomoto/hlda.cpp

@@ -0,0 +1,71 @@
+#include <HLDA.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_hlda(Rice::Module& m) {
+  Rice::define_class_under<tomoto::IHLDAModel, tomoto::ILDAModel>(m, "HLDA")
+    .define_singleton_function(
+      "_new",
+      [](size_t tw, size_t levelDepth, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, size_t seed) {
+        tomoto::HLDAArgs args;
+        args.k = levelDepth;
+        args.alpha = {alpha};
+        args.eta = eta;
+        args.gamma = gamma;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::IHLDAModel::create((tomoto::TermWeight)tw, args);
+      }, Rice::Return().takeOwnership())
+    .define_method(
+      "alpha",
+      [](tomoto::IHLDAModel& self) {
+        Array res;
+        for (size_t i = 0; i < self.getLevelDepth(); i++) {
+          res.push(self.getAlpha(i));
+        }
+        return res;
+      })
+    .define_method(
+      "_children_topics",
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+        return self.getChildTopicId(topic_id);
+      })
+    .define_method(
+      "depth",
+      [](tomoto::IHLDAModel& self) {
+        return self.getLevelDepth();
+      })
+    .define_method(
+      "gamma",
+      [](tomoto::IHLDAModel& self) {
+        return self.getGamma();
+      })
+    .define_method(
+      "_level",
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+        return self.getLevelOfTopic(topic_id);
+      })
+    .define_method(
+      "live_k",
+      [](tomoto::IHLDAModel& self) {
+        return self.getLiveK();
+      })
+    .define_method(
+      "_live_topic?",
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+        return self.isLiveTopic(topic_id);
+      })
+    .define_method(
+      "_num_docs_of_topic",
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+        return self.getNumDocsOfTopic(topic_id);
+      })
+    .define_method(
+      "_parent_topic",
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+        return self.getParentTopicId(topic_id);
+      });
+}

data/ext/tomoto/hpa.cpp

@@ -0,0 +1,32 @@
+#include <HPA.h>
+
+#include <rice/rice.hpp>
+
+#include "utils.h"
+
+void init_hpa(Rice::Module& m) {
+  Rice::define_class_under<tomoto::IHPAModel, tomoto::IPAModel>(m, "HPA")
+    .define_singleton_function(
+      "_new",
+      [](size_t tw, size_t k1, size_t k2, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+        tomoto::HPAArgs args;
+        args.k = k1;
+        args.k2 = k2;
+        args.alpha = {alpha};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::IHPAModel::create((tomoto::TermWeight)tw, false, args);
+      }, Rice::Return().takeOwnership())
+    .define_method(
+      "alpha",
+      [](tomoto::IHPAModel& self) {
+        Array res;
+        // use <= to return k+1 elements
+        for (size_t i = 0; i <= self.getK(); i++) {
+          res.push(self.getAlpha(i));
+        }
+        return res;
+      });
+}