rubygrad 1.1.2 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2e2b978ae8290e86a85ad55bdda2c86ceed5fb38d19f8713e6104ce5d1c447d
-  data.tar.gz: 5da44a923ca6d8ed8bcbc55a7a8ac937b1d71d1b8b560854320290d853b2450d
+  metadata.gz: f05df7e74616deb2db9a7c7340e105e0997268d9d2938d07dbabf51395684fe5
+  data.tar.gz: 6179a5c6a57c37411784195a9ca3a15f73debdd06aaeae46a754ff5857e60770
 SHA512:
-  metadata.gz: 68f06f445e60e400c863485ee63c3e919a39df86dc7da2f9c5febdb57c4bcf5475877fbca9356a32d0e9cd5130e2ec290ff910a4f155a7565cb08d0040ac7993
-  data.tar.gz: c0947a0b25cd505594e7d30a1d5da7e48c47f5899e6683047251ba33b720db7ed9456e251826f02ec68947007cf88db802d4ee1c0630c2edaebf4746e2794be5
+  metadata.gz: 2187327cf7c8b2a8e323b90138c49b7bd6cb5c84ed0e784a5c288556525cf0f8c619dd2aef024b6afaa27aad5b4f2a104457e67dd7158a121f41e9b5dfa631c3
+  data.tar.gz: ebb19b5217fb756fa9072dcf9e2b39ff503f93ac94f782cc45e2ffdc73ee85e6f5c9e471d7995d1017aa0697b97437cf5eb56be1cee34d79e30b0aaf4d5818b9

data/lib/nn.rb

@@ -2,14 +2,18 @@ require_relative "value.rb"
 
 class Neuron
 
-    def initialize(number_of_inputs)
+    def initialize(number_of_inputs, activation_function)
         @initial_weights = Array.new(number_of_inputs) { rand(-1.0..1.0) }
         @initial_bias = rand(-1.0..1.0)
 
         @weights = @initial_weights.map { |w| Value.new(w) }
         @bias = Value.new(@initial_bias)
+
+        @activation_function = activation_function
     end
 
+    attr_reader :weights, :bias
+
     def reset_params
         @initial_weights.each_with_index do |w,i|
             @weights[i].value = w
@@ -24,13 +28,15 @@ class Neuron
         (1...params.size).each { |i| @weights[i - 1].value = params[i] }
     end
 
-    attr_reader :weights, :bias
+    def set_activation_function(activation_function)
+        @activation_function = activation_function
+    end
 
     def parameters
         self.weights + [self.bias]
     end
     
-    def calc(inputs, activation)
+    def calc(inputs)
         # xw + b
         n = self.weights.size
         raise "Wrong number of inputs! #{inputs.size} expected #{n}" unless n == inputs.size
@@ -38,25 +44,26 @@ class Neuron
         n.times do |index|
             sum += self.weights[index] * inputs[index]
         end
-        if activation == :tanh
+        if @activation_function == :tanh
             sum.tanh
-        elsif activation == :relu
+        elsif @activation_function == :relu
             sum.relu
-        elsif activation == :sigmoid
+        elsif @activation_function == :sigmoid
             sum.sigmoid
         else
-            raise "Unsupported activation function: #{activation}"
+            raise "Unsupported activation function: #{activation_function}"
         end
     end
 end
 
 class Layer
 
-    def initialize(number_of_inputs, number_of_outputs)
-        @neurons = Array.new(number_of_outputs) { Neuron.new(number_of_inputs) }
+    def initialize(number_of_inputs, number_of_outputs, activation_function)
+        @neurons = Array.new(number_of_outputs) { Neuron.new(number_of_inputs, activation_function) }
+        @activation_function = activation_function
     end
 
-    attr_reader :neurons
+    attr_reader :neurons, :activation_function
 
     def parameters
         params = []
@@ -68,10 +75,15 @@ class Layer
         self.neurons.each { |n| n.reset_params }
     end
 
-    def calc(inputs, activation)
+    def set_activation_function(activation_function)
+        @activation_function = activation_function
+        self.neurons.each { |n| n.set_activation_function(activation_function) }
+    end
+
+    def calc(inputs)
         outs = []
         self.neurons.each do |neuron|
-            outs << neuron.calc(inputs, activation)
+            outs << neuron.calc(inputs)
         end
         outs
     end
@@ -80,18 +92,58 @@ end
 class MLP 
     
     def initialize(*layers_config)
-        number_of_layers = layers_config.size
+
+        number_of_layers = layers_config.size - 1 # last param is the activation function
+
+        act_array = validate_act_array(layers_config.last, number_of_layers)
+
         @layers = Array.new(number_of_layers - 1) # input layer is not really a layer object
         (number_of_layers - 1).times do |i|
-            @layers[i] = Layer.new(layers_config[i], layers_config[i + 1])
+            @layers[i] = Layer.new(layers_config[i], layers_config[i + 1], act_array[i])
         end
+
         @layers_config = layers_config
     end
 
+    private def validate_act_array(act, number_of_layers)
+
+        if !act.is_a?(Symbol) and !act.is_a?(Array)
+            raise "Activation function must be passed as the last parameter: #{act.class} expected Symbol or Array of Symbols" 
+        end
+
+        if act.is_a?(Array)
+
+            if not act.all? { |item| item.is_a?(Symbol) }
+                raise "Array with activation functions must contain symbols: #{act}"
+            end
+
+            if act.size == 1
+                return Array.new(number_of_layers - 1) { act.first } 
+            end
+
+            if act.size != number_of_layers - 1
+                raise "Array size does not match number of layers with activation functions: #{act.size} expected #{number_of_layers - 1}"
+            end
+
+            return act
+
+        else # is a Symbol
+
+            return Array.new(number_of_layers - 1) { act }
+
+        end
+    end
+
     attr_reader :layers
 
     def inspect
-        "MLP(#{@layers_config.join(", ")})"
+        lay = @layers_config[0..-2].join(", ") # slice to remove last element
+        act = @layers_config.last.inspect
+        "MLP(#{lay}, #{act})"
+    end
+
+    def to_s
+        inspect
     end
 
     def parameters
@@ -102,11 +154,11 @@ class MLP
 
     def show_params(in_words = false)
         if in_words
-            n = @layers_config[0]
+            n = @layers_config.first
             puts "Layer 0: (#{n} input#{n > 1 ? "s" : ""})"
             self.layers.each_with_index do |layer, i|
                 n = layer.neurons.size
-                puts "Layer #{i + 1}: (#{n} neuron#{n > 1 ? "s" : ""})"
+                puts "Layer #{i + 1}: (#{n} neuron#{n > 1 ? "s" : ""}, #{layer.activation_function.inspect} activation)"
                 layer.neurons.each_with_index do |neuron, ii|
                     n = neuron.weights.size
                     puts "\tNeuron #{ii + 1}: (#{n} weight#{n > 1 ? "s" : ""})"
@@ -116,7 +168,7 @@ class MLP
                 end
             end
         else
-            n = @layers_config[0]
+            n = @layers_config.first
             self.layers.each_with_index do |layer, i|
                 n = layer.neurons.size
                 puts "["
@@ -142,14 +194,19 @@ class MLP
         end
     end
 
+    def set_activation_function(activation_function)
+        act_array = validate_act_array(activation_function, @layers_config.size - 1)
+        self.layers.each_with_index { |layer, i| layer.set_activation_function(act_array[i]) }
+    end
+
     def zero_grad
         self.parameters.each { |p| p.grad = 0.0 }
     end
 
-    def calc(inputs, activation)
+    def calc(inputs)
         out = inputs
         self.layers.each do |layer|
-            out = layer.calc(out, activation) # chain the results forward, layer by layer
+            out = layer.calc(out) # chain the results forward, layer by layer
         end
         out.size == 1 ? out[0] : out # for convenience
     end

data/mlp_example.rb

@@ -1,14 +1,28 @@
-require_relative 'lib/nn.rb'
+require 'rubygrad'
+#require_relative 'lib/nn.rb'
 
-nn = MLP.new(3, 4, 4, 1)
+# Build a Machine Learning Perceptron with 4 layers
+# First  Layer (Layer 0) => Input Layer  => 3 Neurons => 3 Inputs
+# Second Layer (Layer 1) => Hidden Layer => 4 Neurons
+# Third  Layer (Layer 2) => Hidden Layer => 4 Neurons
+# Fourth Layer (Layer 3) => Output Layer => 1 Neuron => 1 Output
+nn = MLP.new(3, 4, 4, 1, :tanh)
 
+nn.show_params
+puts
+nn.show_params(in_words = true)
+puts
+
+# 4 input samples
 x_inputs = [
     [2.0, 3.0, -1.0],
     [3.0, -1.0, 0.5],
     [0.5, 1.0, 1.0],
     [1.0, 1.0, -1.0]
 ]
-y_expected = [1.0, -1.0, -1.0, 1.0] # desired
+
+# expected output for each of the 4 inputs above
+y_expected = [1.0, -1.0, -1.0, 1.0]
 
 passes = 2000
 learning_rate = 0.2
@@ -20,7 +34,7 @@ _loss_format = "%.#{_loss_precision}f"
 (0...passes).each do |pass| 
 
     # forward pass (calculate output)
-    y_calculated = x_inputs.map { |x| nn.calc(x, :tanh) }
+    y_calculated = x_inputs.map { |x| nn.calc(x) }
 
     # loss function (check how good the neural net is)
     loss = 0.0
@@ -38,6 +52,7 @@ _loss_format = "%.#{_loss_precision}f"
     break if loss.value == 0 # just for fun and just in case
 end
 
-y_calculated = x_inputs.map { |x| nn.calc(x, :tanh) }
+y_calculated = x_inputs.map { |x| nn.calc(x) }
 puts
-puts y_calculated
+puts "Final NN results:"
+y_calculated.each_with_index { |y_c, i| puts "Output: #{y_c} => Expected: #{y_expected[i]}" }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubygrad
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.2
 platform: ruby
 authors:
 - Sergio Oliveira Jr
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-21 00:00:00.000000000 Z
+date: 2023-03-22 00:00:00.000000000 Z
 dependencies: []
 description:
 email: sergio.oliveira.jr@gmail.com
@@ -40,7 +40,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.9
 signing_key:
 specification_version: 4
 summary: A port of Andrej Karpathy's micrograd to Ruby.