reem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 21a616566baa006fcc7d121ca0d863beb7ce12f0
+  data.tar.gz: 7a7f6be47462eefe9901979414cf2cdf3a204a7e
+SHA512:
+  metadata.gz: 58f172e95a0878b849778ea9029d81d32c0119d284c73f2967c1cf8010e888793839bbb086dc9603bec0234519bcfbe086ec7dd7e1c13e1fc5ee5f5b5987b00e
+  data.tar.gz: c59f57537da4203167f48da999f7deefc15912a864074b8244fb7152a6b821131a02a67d35ab61a8fbc984acdeb6836979e9022f9184e7b7d5d93bf32c2b5555

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+gemspec
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'         # if using anything in the ruby standard library
+  gem 'psych'                    # if using yaml
+  gem 'minitest'                 # if using minitest
+  gem 'rubinius-developer_tools' # if using any of coverage, debugger, profiler
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Matthew Kirk
+
+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/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+    test.libs << 'test'
+    test.warning = true
+    test.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test

data/lib/reem.rb

@@ -0,0 +1,8 @@
+require 'narray'
+
+module Reem
+  autoload :Version, 'reem/version'
+  autoload :LowerTriangularMatrix, 'reem/lower_triangular_matrix'
+  autoload :Clusterer, 'reem/clusterer'
+  autoload :MultivariateGaussian, 'reem/multivariate_gaussian'
+end

data/lib/reem/cholesky_factorization.rb

@@ -0,0 +1,33 @@
+module Reem
+  class CholeskyFactorization
+    def initialize(matrix)
+      @matrix = matrix
+      @lower = LowerTriangularMatrix.new(matrix)
+      decompose!
+    end
+
+    def decompose!
+      @lower.n.times do |j|
+        # Sqrt the diagonal
+        @lower[j,j] = Math::sqrt(@lower[j,j])
+        # Divide the subdiagonal colum by the diagonal
+
+        (j + 1...@lower.m).each do |i|
+          @lower[i,j] = @lower[i,j] / @lower[j,j]
+        end
+
+        # symmetric rank 1 update
+        # subtract the crossproduct of the
+        # subdiagonal column from the remaining
+        # lower diagonal
+        (j+1...@lower.n).each do |k|
+          (k...@lower.m).each do |l|
+            @lower[l,k] = @lower[l, k] - @lower[l,k] * @lower[k,j]
+          end
+        end
+      end
+
+      @upper = @lower.transpose
+    end
+  end
+end

data/lib/reem/clusterer.java

@@ -0,0 +1,183 @@
+public class EMClusterer extends AbstractConditionalDistribution implements FunctionApproximater {
+    /**
+     * The tolerance
+     */
+    private static final double TOLERANCE = 1E-6;
+    /**
+     * The tolerance
+     */
+    private static final int MAX_ITERATIONS = 1000;
+    /**
+     * The mixture distribution
+     */
+    private MixtureDistribution mixture;
+    /**
+     * The number of clusters
+     */
+    private int k;
+    /**
+     * The threshold
+     */
+    private double tolerance;
+
+    /**
+     * The max iterations
+     */
+    private int maxIterations;
+
+    /**
+     * How many iterations it took
+     */
+    private int iterations;
+
+    /**
+     * Whether to print stuff
+     */
+    private boolean debug = false;
+
+    /**
+     * Make a new em clusterer
+     * @param k the number of clusters
+     * @param tolerance the tolerance
+     */
+    public EMClusterer(int k, double tolerance, int maxIterations) {
+        this.k = k;
+        this.tolerance = tolerance;
+        this.maxIterations = maxIterations;
+    }
+
+    /**
+     * Make a new clusterer
+     */
+    public EMClusterer() {
+        this(2, TOLERANCE, MAX_ITERATIONS);
+    }
+
+    /**
+     * @see func.Classifier#classDistribution(shared.Instance)
+     */
+    public Distribution distributionFor(Instance instance) {
+        // calculate the log probs
+        double[] probs = new double[mixture.getComponents().length];
+        double maxLog = Double.NEGATIVE_INFINITY;
+        for (int i = 0; i < probs.length; i++) {
+            probs[i] = mixture.getComponents()[i].logp(instance);
+            maxLog = Math.max(maxLog, probs[i]);
+        }
+        // turn into real probs
+        double sum = 0;
+        for (int i = 0; i < probs.length; i++) {
+            probs[i] = Math.exp(probs[i] - maxLog);
+            sum += probs[i];
+        }
+        // normalize
+        for (int i = 0; i < probs.length; i++) {
+            probs[i] /= sum;
+        }
+        return new DiscreteDistribution(probs);
+    }
+
+    /**
+     * @see func.FunctionApproximater#estimate(shared.DataSet)
+     */
+    public void estimate(DataSet set) {
+        // kmeans initialization
+        KMeansClusterer kmeans = new KMeansClusterer(k);
+        kmeans.estimate(set);
+        double[] prior = new double[k];
+        double weightSum = 0;
+        int[] counts = new int[k];
+        int[] classifications = new int[set.size()];
+        for (int i = 0; i < set.size(); i++) {
+            classifications[i] = kmeans.value(set.get(i)).getDiscrete();
+            counts[classifications[i]]++;
+            prior[classifications[i]] += set.get(i).getWeight();
+            weightSum += set.get(i).getWeight();
+        }
+        // create data sets for each of the classes
+        Instance[][] instances = new Instance[k][];
+        for (int i = 0; i < instances.length; i++) {
+            instances[i] = new Instance[counts[i]];
+        }
+        Arrays.fill(counts, 0);
+        for (int i = 0; i < set.size(); i++) {
+            instances[classifications[i]][counts[classifications[i]]] = set.get(i);
+            counts[classifications[i]]++;
+        }
+        MultivariateGaussian[] initial = new MultivariateGaussian[k];
+        for (int i = 0; i < initial.length; i++) {
+            initial[i] = new MultivariateGaussian();
+            initial[i].setDebug(debug);
+            initial[i].estimate(new DataSet(instances[i]));
+            prior[i] /= weightSum;
+        }
+        mixture = new MixtureDistribution(initial, prior);
+        // reestimate
+        boolean done = false;
+        double lastLogLikelihood = 0;
+        iterations = 0;
+        while (!done) {
+            if (debug) {
+                System.out.println("On iteration " + iterations);
+                System.out.println(mixture);
+            }
+            mixture.estimate(set);
+            double logLikelihood = 0;
+            for (int j = 0; j < set.size(); j++) {
+                logLikelihood += mixture.logp(set.get(j));
+            }
+            logLikelihood /= set.size();
+            done = (iterations > 0 && Math.abs(logLikelihood - lastLogLikelihood) < tolerance)
+                || (iterations + 1 >= maxIterations);
+            lastLogLikelihood = logLikelihood;
+            iterations++;
+        }
+    }
+
+    /**
+     * @see func.FunctionApproximater#value(shared.Instance)
+     */
+    public Instance value(Instance i) {
+        return distributionFor(i).mode();
+    }
+
+    /**
+     * Get the number of iterations it took
+     * @return the number
+     */
+    public int getIterations() {
+        return iterations;
+    }
+
+    /**
+     * Is debug mode on
+     * @return true if it is
+     */
+    public boolean isDebug() {
+        return debug;
+    }
+
+    /**
+     * Set debug mode on or off
+     * @param b the debug mode
+     */
+    public void setDebug(boolean b) {
+        debug = b;
+    }
+
+    /**
+     * Get the mixture
+     * @return the mixture
+     */
+    public MixtureDistribution getMixture() {
+        return mixture;
+    }
+
+    /**
+     * @see java.lang.Object#toString()
+     */
+    public String toString() {
+        return mixture.toString();
+    }
+
+}

data/lib/reem/clusterer.rb

@@ -0,0 +1,10 @@
+module Reem
+  class Clusterer
+    TOLERANCE = 1E-6.freeze
+    MAX_ITERATIONS = 1000.freeze
+
+    def initialize(k = 2, tolerance = TOLERANCE, max_iterations = MAX_ITERATIONS)
+
+    end
+  end
+end

data/lib/reem/lower_triangular_matrix.rb

@@ -0,0 +1,27 @@
+module Reem
+  class LowerTriangularMatrix
+    def initialize(matrix)
+      columns, rows = matrix.sizes
+      @ltm = NArray.float(columns, rows)
+
+      (0...columns).each do |i|
+        (0..i).each do |j|
+          @ltm[j,i] = matrix[j,i]
+        end
+      end
+    end
+
+    def transpose
+      @transpose ||= begin
+        columns, rows = @ltm.sizes
+        matrix = NArray.float(columns, rows)
+        (0...columns).each do |i|
+          (0...rows).each do |j|
+            matrix[i,j] = @ltm[j,i]
+          end
+        end
+        matrix
+      end
+    end
+  end
+end

data/lib/reem/multivariate_gaussian.rb

@@ -0,0 +1,13 @@
+module Reem
+  class MultivariateGaussian
+    FLOOR = 0.01
+    FLOOR_CHAGNE = 10
+
+    def initialize(vector_mean, covariance, floor)
+      @mean = mean
+      @covariance = covariance
+      @floor = floor
+
+    end
+  end
+end

data/lib/reem/version.rb

@@ -0,0 +1,7 @@
+module Reem
+  VERSION = {
+    :major => 0,
+    :minor => 0,
+    :patch => 1
+  }.values.join('.').freeze
+end

data/reem.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/reem/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Matt Kirk"]
+  gem.email         = ["matt@matthewkirk.com"]
+  gem.description   = gem.summary = "Simple EM Clustering for Ruby"
+  gem.homepage      = "http://github.com/hexgnu/reem"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "reem"
+  gem.require_paths = ["lib"]
+  gem.version       = Reem::VERSION
+  gem.add_dependency 'narray'
+  gem.add_development_dependency      'minitest'
+end

data/test/clusterer_test.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+describe Reem::Clusterer do
+  it 'separates two obvious gaussians into two clusters' do
+    skip
+    mga = MultivariateGaussian.new(Vector[100,100,100], Matrix.identity(3) * 0.01)
+    mba = MultivariateGaussian.new(Vector[-1,-1,-1], Matrix.identity(3) * 10)
+
+    instances = instances.length.times.map do |i|
+      if Distribution.random.next_boolean
+        mga.sample(nil)
+      else
+        mgb.sample(nil)
+      end
+    end
+    set = ::Reem::DataSet.new(instances)
+    em = ::Reem::Clusterer.new
+    puts em.estimate(set)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+$TESTING = true
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'bundler'
+Bundler.require
+require 'reem'

data/test/lower_triangular_matrix_test.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+describe ::Reem::LowerTriangularMatrix do
+  let(:matrix) { NArray[[1,2,3], [4,5,6], [7,8,9]] }
+  let(:lower_triangle) { NArray[[1.0,0.0,0.0], [4.0,5.0,0.0], [7.0,8.0,9.0]] }
+  let(:upper_triangle) { NArray[[1.0, 4.0, 7.0], [0.0, 5.0, 8.0], [0.0, 0.0, 9.0]]}
+
+  it 'should convert to a lower triangular matrix' do
+    ltm = ::Reem::LowerTriangularMatrix.new(matrix)
+    ltm.instance_variable_get("@ltm").must_equal lower_triangle
+  end
+
+  it 'transposes' do
+    ltm = ::Reem::LowerTriangularMatrix.new(matrix)
+    ltm.transpose.must_equal upper_triangle
+  end
+end

data/test/multivariate_gaussian_test.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+describe ::Reem::MultivariateGaussian do
+  it 'blends' do
+    skip
+    mga = ::Reem::MultivariateGaussian.new(Vector[100,100,100], Matrix.identity(3) * 0.01)
+
+    instances = 20.times.map do |i|
+      mga.sample
+    end
+
+    set = DataSet.new(instances)
+    mg = MultivariateGaussian
+    mg.estimate(set)
+
+    puts mg
+    puts "Most likely #{mg.mode}"
+
+    10.times do |i|
+      puts mg.sample
+    end
+
+    instances.each do |instance|
+      puts "Probability of \n #{instance} \n #{mg.p(instance)}"
+    end
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: reem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matt Kirk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple EM Clustering for Ruby
+email:
+- matt@matthewkirk.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Changes.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/reem.rb
+- lib/reem/.clusterer.rb.swp
+- lib/reem/cholesky_factorization.rb
+- lib/reem/clusterer.java
+- lib/reem/clusterer.rb
+- lib/reem/lower_triangular_matrix.rb
+- lib/reem/multivariate_gaussian.rb
+- lib/reem/version.rb
+- reem.gemspec
+- test/clusterer_test.rb
+- test/helper.rb
+- test/lower_triangular_matrix_test.rb
+- test/multivariate_gaussian_test.rb
+homepage: http://github.com/hexgnu/reem
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Simple EM Clustering for Ruby
+test_files:
+- test/clusterer_test.rb
+- test/helper.rb
+- test/lower_triangular_matrix_test.rb
+- test/multivariate_gaussian_test.rb
+has_rdoc: