lda-ruby 0.5.0-x64-mingw-ucrt

data/lda-ruby.gemspec

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "lib/lda-ruby/version"
+
+variant = ENV.fetch("LDA_RUBY_GEM_VARIANT", "source")
+valid_variants = %w[source precompiled].freeze
+unless valid_variants.include?(variant)
+  raise ArgumentError, "Unsupported LDA_RUBY_GEM_VARIANT=#{variant.inspect}. Expected one of: #{valid_variants.join(', ')}"
+end
+
+precompiled_variant = variant == "precompiled"
+
+Gem::Specification.new do |spec|
+  spec.name = "lda-ruby"
+  spec.version = Lda::VERSION
+  spec.authors = ["David Blei", "Jason Adams", "Rio Akasaka"]
+  spec.email = ["jasonmadams@gmail.com"]
+
+  spec.summary = "Ruby implementation of Latent Dirichlet Allocation (LDA)."
+  spec.description = "Ruby wrapper and toolkit for Latent Dirichlet Allocation based on the original lda-c implementation by David M. Blei."
+  spec.homepage = "https://github.com/ealdent/lda-ruby"
+  spec.license = "GPL-2.0-or-later"
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/master/CHANGELOG.md",
+    "lda_ruby_gem_variant" => variant
+  }
+
+  if precompiled_variant
+    platform_override = ENV.fetch("LDA_RUBY_GEM_PLATFORM", "").strip
+    platform_value = platform_override.empty? ? Gem::Platform.local.to_s : platform_override
+
+    spec.platform = Gem::Platform.new(platform_value)
+    spec.metadata["lda_ruby_platform"] = spec.platform.to_s
+    spec.extensions = []
+  else
+    spec.extensions = ["ext/lda-ruby/extconf.rb", "ext/lda-ruby-rust/extconf.rb"]
+  end
+
+  spec.require_paths = ["lib"]
+
+  included = %w[CHANGELOG.md Gemfile README.md VERSION.yml lda-ruby.gemspec license.txt]
+  included += Dir.glob("docs/**/*")
+  included += Dir.glob("ext/**/*")
+  included += Dir.glob("lib/**/*")
+  included += Dir.glob("test/**/*")
+  allowed_precompiled_binary_patterns = [
+    %r{\Alib/lda-ruby/lda\.(so|bundle|dylib|dll)\z},
+    %r{\Alib/lda_ruby_rust\.(so|bundle|dylib|dll)\z}
+  ]
+
+  spec.files = included
+    .reject { |path| File.directory?(path) }
+    .reject { |path| path.start_with?("ext/lda-ruby-rust/target/") }
+    .reject { |path| path == "ext/lda-ruby-rust/Cargo.lock" }
+    .reject do |path|
+      next false if precompiled_variant && allowed_precompiled_binary_patterns.any? { |pattern| pattern.match?(path) }
+
+      path.end_with?(".o", ".so", ".bundle", ".dylib", ".dll", ".rlib", ".rmeta")
+    end
+    .reject do |path|
+      ["Makefile", "ext/lda-ruby/Makefile", "ext/lda-ruby/mkmf.log", "ext/lda-ruby-rust/Makefile"].include?(path)
+    end
+    .uniq
+    .sort
+
+  if precompiled_variant
+    missing_binaries = allowed_precompiled_binary_patterns.reject do |pattern|
+      spec.files.any? { |path| pattern.match?(path) }
+    end
+    unless missing_binaries.empty?
+      raise "Precompiled variant requires staged binaries under lib/: #{missing_binaries.map(&:source).join(', ')}"
+    end
+  end
+end

data/lib/lda-ruby/backends/base.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Lda
+  module Backends
+    class Base
+      attr_reader :corpus
+
+      attr_accessor :max_iter,
+                    :convergence,
+                    :em_max_iter,
+                    :em_convergence,
+                    :num_topics,
+                    :init_alpha,
+                    :est_alpha,
+                    :verbose
+
+      def initialize(random_seed: nil)
+        @random = random_seed.nil? ? Random.new : Random.new(random_seed)
+
+        @max_iter = 20
+        @convergence = 1e-6
+        @em_max_iter = 100
+        @em_convergence = 1e-4
+        @num_topics = 20
+        @init_alpha = 0.3
+        @est_alpha = 1
+        @verbose = true
+
+        @corpus = nil
+      end
+
+      def name
+        self.class.name.split("::").last.downcase
+      end
+
+      def corpus=(corpus)
+        @corpus = corpus
+        true
+      end
+
+      def fast_load_corpus_from_file(filename)
+        self.corpus = Lda::DataCorpus.new(filename)
+      end
+
+      def load_settings(settings_file)
+        File.readlines(settings_file).each do |line|
+          next if line.strip.empty? || line.strip.start_with?("#")
+
+          key, value = line.split(/\s+/, 2)
+          next if value.nil?
+
+          case key.downcase
+          when "max_iter", "var_max_iter"
+            self.max_iter = value.to_i
+          when "convergence", "var_converged"
+            self.convergence = value.to_f
+          when "em_max_iter"
+            self.em_max_iter = value.to_i
+          when "em_convergence", "em_converged"
+            self.em_convergence = value.to_f
+          when "num_topics", "ntopics"
+            self.num_topics = value.to_i
+          when "init_alpha", "initial_alpha", "alpha"
+            self.init_alpha = value.to_f
+          when "est_alpha", "estimate_alpha"
+            self.est_alpha = value.to_i
+          when "verbose"
+            self.verbose = value.to_i != 0
+          end
+        end
+
+        true
+      end
+
+      def set_config(init_alpha, num_topics, max_iter, convergence, em_max_iter, em_convergence, est_alpha)
+        self.init_alpha = init_alpha
+        self.num_topics = num_topics
+        self.max_iter = max_iter
+        self.convergence = convergence
+        self.em_max_iter = em_max_iter
+        self.em_convergence = em_convergence
+        self.est_alpha = est_alpha
+        true
+      end
+
+      def em(_start)
+        raise NotImplementedError, "#{self.class} must implement #em"
+      end
+
+      def beta
+        raise NotImplementedError, "#{self.class} must implement #beta"
+      end
+
+      def gamma
+        raise NotImplementedError, "#{self.class} must implement #gamma"
+      end
+
+      def compute_phi
+        raise NotImplementedError, "#{self.class} must implement #compute_phi"
+      end
+
+      def model
+        raise NotImplementedError, "#{self.class} must implement #model"
+      end
+
+      def topic_document_probability(_phi_matrix, _document_counts)
+        nil
+      end
+
+      private
+
+      def next_random_seed
+        @random.rand(0..9_223_372_036_854_775_807)
+      end
+
+      def normalize!(weights)
+        total = weights.sum.to_f
+
+        if total <= 0.0
+          uniform = 1.0 / weights.size
+          weights.map! { uniform }
+          return weights
+        end
+
+        weights.map! { |w| w / total }
+      end
+
+      def clone_matrix(matrix)
+        Marshal.load(Marshal.dump(matrix))
+      end
+    end
+  end
+end

data/lib/lda-ruby/backends/native.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Lda
+  module Backends
+    class Native < Base
+      REQUIRED_NATIVE_METHODS = %i[
+        __native_fast_load_corpus_from_file
+        __native_load_settings
+        __native_set_config
+        __native_em
+        __native_beta
+        __native_gamma
+        __native_compute_phi
+        __native_model
+        __native_set_corpus
+        __native_max_iter
+        __native_set_max_iter
+        __native_convergence
+        __native_set_convergence
+        __native_em_max_iter
+        __native_set_em_max_iter
+        __native_em_convergence
+        __native_set_em_convergence
+        __native_init_alpha
+        __native_set_init_alpha
+        __native_num_topics
+        __native_set_num_topics
+        __native_est_alpha
+        __native_set_est_alpha
+        __native_verbose
+        __native_set_verbose
+      ].freeze
+
+      def self.available?(host)
+        REQUIRED_NATIVE_METHODS.all? { |method_name| host.respond_to?(method_name, true) }
+      end
+
+      def initialize(host, random_seed: nil)
+        super(random_seed: random_seed)
+        @host = host
+      end
+
+      def name
+        "native"
+      end
+
+      def corpus=(corpus)
+        @corpus = corpus
+        @host.__send__(:__native_set_corpus, corpus)
+      end
+
+      def fast_load_corpus_from_file(filename)
+        @host.__send__(:__native_fast_load_corpus_from_file, filename)
+      end
+
+      def load_settings(settings_file)
+        @host.__send__(:__native_load_settings, settings_file)
+      end
+
+      def set_config(init_alpha, num_topics, max_iter, convergence, em_max_iter, em_convergence, est_alpha)
+        @host.__send__(
+          :__native_set_config,
+          init_alpha,
+          num_topics,
+          max_iter,
+          convergence,
+          em_max_iter,
+          em_convergence,
+          est_alpha
+        )
+      end
+
+      def max_iter
+        @host.__send__(:__native_max_iter)
+      end
+
+      def max_iter=(value)
+        @host.__send__(:__native_set_max_iter, Integer(value))
+      end
+
+      def convergence
+        @host.__send__(:__native_convergence)
+      end
+
+      def convergence=(value)
+        @host.__send__(:__native_set_convergence, Float(value))
+      end
+
+      def em_max_iter
+        @host.__send__(:__native_em_max_iter)
+      end
+
+      def em_max_iter=(value)
+        @host.__send__(:__native_set_em_max_iter, Integer(value))
+      end
+
+      def em_convergence
+        @host.__send__(:__native_em_convergence)
+      end
+
+      def em_convergence=(value)
+        @host.__send__(:__native_set_em_convergence, Float(value))
+      end
+
+      def init_alpha
+        @host.__send__(:__native_init_alpha)
+      end
+
+      def init_alpha=(value)
+        @host.__send__(:__native_set_init_alpha, Float(value))
+      end
+
+      def num_topics
+        @host.__send__(:__native_num_topics)
+      end
+
+      def num_topics=(value)
+        @host.__send__(:__native_set_num_topics, Integer(value))
+      end
+
+      def est_alpha
+        @host.__send__(:__native_est_alpha)
+      end
+
+      def est_alpha=(value)
+        @host.__send__(:__native_set_est_alpha, Integer(value))
+      end
+
+      def verbose
+        @host.__send__(:__native_verbose)
+      end
+
+      def verbose=(value)
+        @host.__send__(:__native_set_verbose, !!value)
+      end
+
+      def em(start)
+        @host.__send__(:__native_em, start)
+      end
+
+      def beta
+        @host.__send__(:__native_beta)
+      end
+
+      def gamma
+        @host.__send__(:__native_gamma)
+      end
+
+      def compute_phi
+        @host.__send__(:__native_compute_phi)
+      end
+
+      def model
+        @host.__send__(:__native_model)
+      end
+    end
+  end
+end