phren 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a36bbbd6ba022487b4efab719fe04f00f4155c2
+  data.tar.gz: 20e811f45f8fe96a561c99a645d868e89b504563
+SHA512:
+  metadata.gz: dfcf6737c205c14ec1c275a68873d90b84dd2300c0541b2c6e2318bec6e09d9db5858b3918d312659e338987c630dab51b2c992afcf5325b468c6ed3f16eeb4b
+  data.tar.gz: 853e584e3449abc2a67f2644df6302b4bdd7c82d7943d68a64b8775d82d7f498b171011bc4336ab4c7aee76b37977d569b50995805367778b49e24dd78044df9

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :spec

data/lib/layer.rb

@@ -0,0 +1,17 @@
+module Phren
+
+  class Layer
+
+    attr_reader :id, :neurons, :length
+    
+    def initialize(length, id)
+      @length = length
+      @id = id # num of layer starting from 0. if it's negative neurons are bias
+      @neurons = Array.new(@length) { |i|
+        Neuron.new(@id < 0 ? 1 : 0,[@id, i])
+      }
+    end
+    
+  end
+  
+end

data/lib/moldmaker.rb

@@ -0,0 +1,131 @@
+module Phren
+  class Moldmaker
+
+    # @option opts [Float] :molding_rate
+    # @option opts [Float] :momentum
+    # @option opts [Integer] :max_iterations
+    def initialize(opts = {})
+      @molding_rate = opts[:molding_rate]
+      @momentum = opts[:momentum]
+      @max_iterations = opts[:max_iterations]
+      end
+
+    # @param [Phren::Network] an architecture of network
+    # @param [Array] with elements array of inputs
+    # @param [Array] with elements array of outputs
+    def mold(network, stimulus, expected_responses)
+      @network = network
+
+      1.upto(@max_iterations) { |iter|
+        stimulus.each_index { |i|
+          self.irritate(stimulus[i])
+          self.learn(expected_responses[i])
+        }
+      }
+      
+    end
+    
+    def irritate(stimuli)
+      
+      0.upto(@network.num_of_inputs-1) { |i|
+        @network.layers[0].neurons[i].value = stimuli[i]
+      }
+      
+      
+      
+      1.upto(@network.num_of_layers-1) { |l|
+        @network.layers[l].neurons.each { |n|
+          n.value = net_input(n)
+          n.value = sig(n.value)
+        }
+      }
+      
+    end
+    
+    def test(inputs)
+      outputs = []
+      irritate(inputs)
+      @network.layers[@network.num_of_layers-1].neurons.each { |n|
+        outputs << n.value
+      }
+
+      return outputs
+      
+    end
+
+
+    def learn(expected_response)
+
+      @network.layers[@network.num_of_layers-1].neurons.each_with_index { |n, i|
+        expected_value = expected_response[i]
+        n.error_signal = n.value * (1 - n.value) * (n.value - expected_value)
+      }
+
+      # compute deltas - error_signal
+      
+      
+      (@network.num_of_layers-2).downto(0) { |l|
+        @network.layers[l].neurons.each { |n|
+          n.error_signal = n.value * (1 - n.value) * net_output(n)
+        }
+      }
+
+      # TODO reduce it to one forloop
+      1.upto(@network.num_of_layers-1) { |l|
+        @network.layers[l].neurons.each { |n|
+          @network.synapses.keys.each { |k|
+            if k[1] == n.id[0]
+              @network.synapses[k].each { |s|
+                if (s.to == n)
+                  w = s.weight
+                  s.weight = s.weight - (@molding_rate * n.error_signal * s.from.value)
+                  #puts "Just updated synapse from Neuron(Layer:#{s.from.id[0]},#{s.from.id[1]} to Neuron(Layer:#{s.to.id[0]},#{s.to.id[1]}) !!"
+                #  puts "From #{w} became #{s.weight} with error signal #{n.error_signal} \n"
+                #  puts "\n\n"
+                end
+              }
+            end
+          }
+        }
+      }
+      
+    end
+
+    def sig(x)
+      return (1 / (1 + Math.exp(-x)))
+    end
+
+    
+    def net_input(neuron)
+      net_j = 0
+      @network.synapses.keys.each { |k|
+        if k[1] == neuron.id[0]
+          @network.synapses[k].each { |s|
+            if (s.to == neuron)
+              # from_synapses << s
+              net_j += (s.from.value * s.weight)
+            end
+          }
+        end
+      }
+      return net_j
+    end
+
+    # να καλείται ως προς το δίκτυο
+    def net_output(neuron)
+      net_o = 0
+      @network.synapses.keys.each { |k|
+        if k[0] == neuron.id[0]
+          @network.synapses[k].each { |s|
+            if (s.from == neuron)
+              net_o += (s.to.error_signal * s.weight)
+            end
+          }
+        end
+      }
+      return net_o
+    end
+    
+    
+  end
+end

data/lib/network.rb

@@ -0,0 +1,48 @@
+module Phren
+  
+  class Network
+
+    attr_reader :synapses, :layers, :num_of_layers
+    attr_reader :num_of_inputs, :num_of_outputs
+    # @param [Array] architecture of network
+    # @opts options
+    def initialize(architecture, opts = {})
+      
+      @synapses = {}
+      @layers = {}
+
+      @num_of_inputs = architecture.first
+      @num_of_outputs = architecture.last
+      
+      @num_of_layers = architecture.length
+
+      # TODO try to implemet it with map
+      @layers[0] = Layer.new(architecture.first, 0)       
+      1.upto(@num_of_layers-1) { |i| # create layers
+        @layers[-i] = Layer.new(1, -i) # bias layer
+        @layers[i] = Layer.new(architecture[i], i)
+      }
+      
+      @layers.keys.each { |k|  # connect layers
+        if( k < 0) # is bias
+          connect_layers(@layers[k], @layers[-k])
+        elsif( k > 0) # is hidden or output layer
+          connect_layers(@layers[k-1], @layers[k])
+        end
+      }
+
+    end
+
+    # According to dontveter.com/bpr/basics.html is faster for xor problem 
+    def connect_input_to_output_layer
+      connect_layers(@layers[0], @layers[@num_of_layers-1])
+    end
+    
+    def connect_layers(from, to)
+      @synapses[[from.id, to.id]] = Array.new(from.length * to.length){ |index|
+        Synapse.new(from.neurons[index % from.length], to.neurons[index % to.length], 0) # 0 could be replace with random
+      }
+    end
+
+  end
+end

data/lib/neuron.rb

@@ -0,0 +1,17 @@
+module Phren
+  
+  class Neuron
+    
+    attr_accessor :value, :error_signal
+    attr_reader :id
+    # @param [Float] value for neuron
+    # @param [Array] [layer id,index]
+    def initialize(value, id)
+      @value = value
+      @id = id
+      @error_signal = 0
+    end
+    
+  end
+  
+end

data/lib/synapse.rb

@@ -0,0 +1,19 @@
+module Phren
+  
+  class Synapse
+    
+    attr_accessor :weight
+    attr_reader :from, :to
+
+    # @param [Phren::Neuron] where synapse starting
+    # @param [Phren::Neuron] where synapse is ending
+    # @param [Phren::Neuron] synapse wheight
+    def initialize(from, to, weight)
+      @from = from
+      @to = to
+      @weight = weight
+    end
+
+  end
+
+end

data/spec/network_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Phren, "#network" do
+  context "with parameters" do
+    it "the network is initialized" do
+      inputs = [[0,0],[0,1],[1,0],[1,1]]
+      outputs = [0,1,1,0]
+      
+      net = Network.new()
+      net.forward
+      expect(net.my_variable).to eq true 
+    end
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: phren
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Savvas Alexandrou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-09 00:00:00.000000000 Z
+dependencies: []
+description: A simple neural network gem
+email: salexa@member.fsf.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/layer.rb
+- lib/moldmaker.rb
+- lib/network.rb
+- lib/neuron.rb
+- lib/synapse.rb
+- spec/network_spec.rb
+homepage: https://github.com/Savinos90/phren
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: Thanks for installing!
+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.5.1
+signing_key: 
+specification_version: 3
+summary: An Artificial Neural Network gem
+test_files:
+- spec/network_spec.rb