mirlo 0.0.1

data/lib/mirlo/datasets/and_dataset.rb

@@ -0,0 +1,13 @@
+module Mirlo
+  class AndDataSet < Dataset
+    def initialize
+      @feature_names = ['x', 'y']
+      @title = "Logical AND dataset"
+
+      samples = [[0,0], [0,1], [1,0], [1,1]]
+      targets = [ZERO, ZERO, ZERO, ONE]
+
+      super(samples: samples, targets: targets)
+    end
+  end
+end

data/lib/mirlo/datasets/double_moon_dataset.rb

@@ -0,0 +1,43 @@
+module Mirlo
+  class DoubleMoonDataSet < Dataset
+    attr_reader :radius, :width, :distance
+
+    DEFAULT_RADIUS   = 10
+    DEFAULT_WIDTH    = 6
+    DEFAULT_DISTANCE = 2
+
+    UPPER_MOON = [1]
+    LOWER_MOON = [0]
+
+    def initialize(n_points: 500, radius: DEFAULT_RADIUS, width: DEFAULT_WIDTH, distance: DEFAULT_DISTANCE)
+      feature_names = ['x', 'y']
+      title = "Double Moon Dataset with radius:=#{radius}, width:=#{width}, distance:=#{distance}"
+      @radius, @width, @distance = radius, width, distance
+      samples = n_points.times.collect { random_point }
+
+      labels = {
+        UPPER_MOON => 'Upper moon',
+        LOWER_MOON => 'Lower moon'
+      }
+
+      super(samples: samples, feature_names: feature_names, title: title, labels: labels)
+    end
+
+    def random_point
+      angle_coord  = rand * Math::PI
+      radial_coord = radius + width * rand(-0.5..0.5)
+
+      target = rand(2) == 1 ? UPPER_MOON : LOWER_MOON
+
+      if target == UPPER_MOON
+        x = radial_coord * Math.cos(angle_coord)
+        y = radial_coord * Math.sin(angle_coord)
+      else
+        x = radial_coord * Math.cos(angle_coord) + radius
+        y = - radial_coord * Math.sin(angle_coord) - distance
+      end
+
+      SampleWithBias.new(target: target, features: [x, y])
+    end
+  end
+end

data/lib/mirlo/datasets/or_dataset.rb

@@ -0,0 +1,13 @@
+module Mirlo
+  class OrDataSet < Dataset
+    def initialize
+      @feature_names = ['x', 'y']
+      @title = "Logical OR dataset"
+
+      samples = [[0,0], [0,1], [1,0], [1,1]]
+      targets = [ZERO, ONE, ONE, ONE]
+
+      super(samples: samples, targets: targets)
+    end
+  end
+end

data/lib/mirlo/datasets/xor_dataset.rb

@@ -0,0 +1,13 @@
+module Mirlo
+  class XorDataSet < Mirlo::Dataset
+    def initialize
+      @feature_names = ['x', 'y']
+      @title = "Logical XOR dataset"
+
+      samples = [[0,0], [0,1], [1,0], [1,1]]
+      targets = [ZERO, ONE, ONE, ZERO]
+
+      super(samples: samples, targets: targets)
+    end
+  end
+end

data/lib/mirlo/extensions/matrix.rb

@@ -0,0 +1,27 @@
+require 'matrix'
+
+class Matrix
+
+  def shape
+    [row_count, column_count]
+  end
+
+  #
+  # Public: given two matrices of equal dimensions, apply an operation elementwise.
+  #
+  # Returns a new matrix with the results of the operation.
+  #
+  def apply_elementwise(other, &op)
+    unless shape == other.shape
+      raise ArgumentError.new 'To perform an element wise operation, matrices must be of the same dimension.'
+    end
+
+    new_rows = row_count.times.collect do |row|
+      column_count.times.collect do |column|
+        op.call(self[row, column], other[row, column])
+      end
+    end
+
+    Matrix.rows(new_rows)
+  end
+end

data/lib/mirlo/plotting.rb

@@ -0,0 +1,30 @@
+module Mirlo
+  module Plotting
+    def plot(x_feature = nil, y_feature = nil)
+      Gnuplot.open do |gp|
+        Gnuplot::Plot.new(gp) do |plot|
+          plot.title title
+          plot.xlabel 'x'
+          plot.ylabel 'y'
+
+          plot.data = to_gnu_plot_datasets
+        end
+      end
+    end
+
+    private
+
+    def to_gnu_plot_datasets
+      target_set.each_with_index.collect do |target, i|
+        subset = subset_with_target(target)
+        x = subset.feature(0)
+        y = subset.feature(1)
+
+        Gnuplot::DataSet.new([x, y]) do |ds|
+          ds.title = label_for(target)
+          ds.with = "points ls #{i+1} lc rgb \"red\""
+        end
+      end
+    end
+  end
+end

data/lib/mirlo/sample.rb

@@ -0,0 +1,34 @@
+class Mirlo::Sample
+  attr_reader :target, :features
+
+  def initialize(target: [], features: [])
+    @target   = target.is_a?(Array) ? target : [target]
+    @features = features
+  end
+
+  def [](index)
+    @features[index]
+  end
+
+  def has_features?(some_features)
+    features == some_features
+  end
+
+  def feature_size
+    features.size
+  end
+
+  def target_size
+    target.size
+  end
+
+  def biased?
+    false
+  end
+
+  def ==(other_sample)
+    target    == other_sample.target &&
+    features  == other_sample.features &&
+    biased?   == other.biased?
+  end
+end

data/lib/mirlo/sample_with_bias.rb

@@ -0,0 +1,19 @@
+class Mirlo::SampleWithBias < Mirlo::Sample
+
+  def initialize(target: [], features: [])
+    super(target: target)
+    @features = features.dup.unshift(-1)
+  end
+
+  def [](index)
+    super(index+1)
+  end
+
+  def has_features?(some_features)
+    features == some_features.dup.unshift(-1)
+  end
+
+  def biased?
+    true
+  end
+end

data/lib/mirlo/test_result.rb

@@ -0,0 +1,49 @@
+class Mirlo::TestResult
+  attr_reader :n_samples
+
+  def initialize(possible_classes = [])
+    @possible_classes = possible_classes
+    @confusion_matrix = Hash.new { 0 }
+    @n_samples = 0
+  end
+
+  def add(sample, prediction)
+    @possible_classes << sample.target unless @possible_classes.include?(sample.target)
+    @confusion_matrix[[sample.target, prediction]] += 1
+    @n_samples += 1
+  end
+
+  def confusion_matrix(expected, prediction)
+    @confusion_matrix[[expected, prediction]]
+  end
+
+  def mean_squared_error
+    errors = @confusion_matrix.collect do |results, times|
+      expected, prediction = results
+      error_for(expected, prediction, times)
+    end
+
+    errors.inject(:+)
+  end
+
+  def n_errors
+    errors = @confusion_matrix.select do |results, times|
+      expected, prediction = results
+      expected != prediction
+    end
+
+    errors.collect { |results, times| times }.inject(:+)
+  end
+
+  def error_percentage
+    n_errors.to_f/n_samples
+  end
+
+  private
+
+  def error_for(expected, prediction, times)
+    diffs = expected.each_with_index.collect { |expected_val, i| expected_val - prediction[i] }
+    squared_errors = diffs.collect { |diff| diff ** 2 }
+    squared_errors.inject(:+) * times
+  end
+end

data/lib/mirlo/version.rb

@@ -0,0 +1,3 @@
+module Mirlo
+  VERSION = "0.0.1"
+end

data/mirlo.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mirlo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mirlo"
+  spec.version       = Mirlo::VERSION
+  spec.authors       = ["Alberto F. Capel"]
+  spec.email         = ["afcapel@gmail.com"]
+  spec.description   = %q{Machine Learning experiments}
+  spec.summary       = %q{Implementation of some Machine Learning algorithms}
+  spec.homepage      = "https://github.com/afcapel/mirlo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "gnuplot"
+end

data/spec/ann/ann_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'ANN DSL' do
+  before :each do
+    @ann = Mirlo::ANN.build do
+      learning_rate 0.25
+
+      input_layer  3
+      hidden_layer 3
+      hidden_layer 2
+      output_layer 3
+    end
+  end
+
+  it "should build a multilayer perceptron" do
+    expect(@ann).to be_kind_of(Mirlo::MultilayerPerceptron)
+  end
+
+  it "can set the learning rate of the neural network" do
+    expect(@ann.learning_rate).to eq 0.25
+  end
+
+  it "can set the number of inputs on the input layer" do
+    expect(@ann.input_layer.size).to eq 4 # 3 inputs plus the bias
+  end
+
+  it "can define hidden layers on the network" do
+    expect(@ann.hidden_layers).to be_kind_of(Array)
+    expect(@ann.hidden_layers.size).to eq 2
+
+    expect(@ann.hidden_layers[0].size).to eq 3
+    expect(@ann.hidden_layers[1].size).to eq 2
+  end
+
+  it "set the connections between layers" do
+    expect(@ann.layers[0].next_layer).to eq @ann.layers[1]
+    expect(@ann.layers[1].next_layer).to eq @ann.layers[2]
+    expect(@ann.layers[2].next_layer).to eq @ann.layers[3]
+
+    expect(@ann.layers[1].previous_layer).to eq @ann.layers[0]
+    expect(@ann.layers[2].previous_layer).to eq @ann.layers[1]
+    expect(@ann.layers[3].previous_layer).to eq @ann.layers[2]
+  end
+
+  it "can set the number of outputs on the output layer" do
+    expect(@ann.output_layer.size).to eq 3
+  end
+
+  it "defines the weight matrices between layers" do
+    weights1 = @ann.layers[1].weights
+    expect(weights1.row_count).to eq 4 # 3 inputs plus the bias
+    expect(weights1.column_count).to eq 3
+
+
+
+    weights2 = @ann.layers[2].weights
+    expect(weights2.row_count).to eq 3
+    expect(weights2.column_count).to eq 2
+  end
+end

data/spec/ann/multilayer_percetron_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Mirlo::MultilayerPerceptron do
+
+  let(:mlp) do
+    Mirlo::ANN.build do
+      input_layer  2
+      hidden_layer 3
+      output_layer 1
+    end
+  end
+
+  it "can classify all data points of the OR logical function" do
+    data_set = Mirlo::OrDataSet.new
+
+    mlp.train_until(data_set, max_error: 0.0, max_iterations: 50_000)
+
+    expect(mlp.classify([0,0])).to eq [0]
+    expect(mlp.classify([0,1])).to eq [1]
+    expect(mlp.classify([1,0])).to eq [1]
+    expect(mlp.classify([1,1])).to eq [1]
+
+    test_result = mlp.test_with(data_set)
+    expect(test_result.mean_squared_error).to eq 0.0
+  end
+
+  it "can classify all data points of the AND logical function" do
+    data_set = Mirlo::AndDataSet.new
+
+    mlp.train_until(data_set, max_error: 0.0, max_iterations: 50_000)
+
+    expect(mlp.classify([0,0])).to eq [0]
+    expect(mlp.classify([0,1])).to eq [0]
+    expect(mlp.classify([1,0])).to eq [0]
+    expect(mlp.classify([1,1])).to eq [1]
+
+    test_result = mlp.test_with(data_set)
+    expect(test_result.mean_squared_error).to eq 0.0
+  end
+
+  it "can classify all data points of the XOR logical function" do
+    data_set = Mirlo::XorDataSet.new
+
+    mlp.train_until(data_set, max_error: 0.0, max_iterations: 50_000)
+
+    expect(mlp.classify([0,0])).to eq [0]
+    expect(mlp.classify([0,1])).to eq [1]
+    expect(mlp.classify([1,0])).to eq [1]
+    expect(mlp.classify([1,1])).to eq [0]
+
+    test_result = mlp.test_with(data_set)
+    expect(test_result.mean_squared_error).to eq 0.0
+  end
+
+end

data/spec/ann/neuron_layer_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Mirlo::NeuronLayer do
+  let(:previous_layer) do
+     input_layer = Mirlo::InputLayer.new(2)
+     input_layer.input = [0.5, 1] # A first -1 bias component will be added
+     input_layer
+  end
+
+  let(:hidden_layer) do
+    hidden_layer = Mirlo::NeuronLayer.new(2)
+    hidden_layer.previous_layer = previous_layer
+    hidden_layer
+  end
+
+  it "has a matrix of weights" do
+    expect(hidden_layer.weights.shape).to eq [3, 2]
+  end
+
+  context "with given weights" do
+    before :each do
+      hidden_layer.build_weight_function = -> { 0.5 }
+    end
+
+    it "allows to set a function to build the weights matrix" do
+      hidden_layer.weights.each do |elm|
+        expect(elm).to eq 0.5
+      end
+    end
+
+    it "can calculate the total input for each neuron" do
+      total_inputs = hidden_layer.inputs_matrix.row(0)
+
+      expect(total_inputs[0]).to be_within(0.00001).of 0.25
+      expect(total_inputs[1]).to be_within(0.00001).of 0.25
+    end
+
+    it "can calculate the activation of each neuron" do
+      activations = hidden_layer.activation_matrix.row(0)
+
+      expect(activations[0]).to be_within(0.00001).of 1.0/(1 + Math.exp(-0.25))
+      expect(activations[1]).to be_within(0.00001).of 1.0/(1 + Math.exp(-0.25))
+    end
+  end
+end