Anyone able to get this to work?

[inspire22]

I'm having the same problem as this guy: http://stackoverflow.com/questions/9746062/training-neural-network-in-ruby

Training doesn't do very well despite pretty predictive data: Max epochs 1000000. Desired error: 0.0010000000. Epochs 1. Current error: 0.7620287538. Bit fail 118. Epochs 100000. Current error: 0.4796932936. Bit fail 195. Epochs 200000. Current error: 0.4797259271. Bit fail 195. Epochs 300000. Current error: 0.4799208045. Bit fail 195. Epochs 400000. Current error: 0.4797225893. Bit fail 195. Epochs 500000. Current error: 0.4799278677. Bit fail 195. Epochs 600000. Current error: 0.4797178209. Bit fail 195. Epochs 700000. Current error: 0.4796698689. Bit fail 195. Epochs 800000. Current error: 0.4795957506. Bit fail 194. Epochs 900000. Current error: 0.4795432389. Bit fail 194. Epochs 1000000. Current error: 0.4797499180. Bit fail 195.

Everything is normalized obviously, otherwise we get segmentation faults.

For each train, output is always a random number that stays the same no matter the input: 2.0.0-p195 :016 > $fann.run([1]) => [0.02257500380258881] 2.0.0-p195 :017 > $fann.run([1,5,3,2,1,4]) => [0.02257500380258881] 2.0.0-p195 :018 > $fann.run([0.1, 0.5, 0.5, 0.5, 0.1, 0.1]) => [0.02257500380258881]

If I re-run training, the result number is different

[inspire22]

Just to reply to myself, debugged with the tic-tac-toe project (clever!) but it is broken as well - fitness always returns 0.0

• this project is dead!

[{:move=>[0, 0, 0, 0, 0, 0, 0, 0, 1], :fitness=>0.0}, {:move=>[0, 0, 0, 0, 0, 0, 0, 1, 0], :fitness=>0.0}, {:move=>[0, 0, 0, 0, 0, 0, 1, 0, 0], :fitness=>0.0}, {:move=>[0, 0, 0, 0, 0, 1, 0, 0, 0], :fitness=>0.0}, {:move=>[0, 0, 0, 1, 0, 0, 0, 0, 0], :fitness=>0.0}, {:move=>[0, 0, 1, 0, 0, 0, 0, 0, 0], :fitness=>0.0}, {:move=>[0, 1, 0, 0, 0, 0, 0, 0, 0], :fitness=>0.0}, {:move=>[1, 0, 0, 0, 0, 0, 0, 0, 0], :fitness=>0.0}] [0, 0, 0, 0, 0, 0, 0, 0, 1]

[groe]

I just ran into the same problem as well while experimenting with the library. Too bad it seems to be unmaintained at the moment :/

[bnolan]

Yeah this project is dead, I can't get it to run an xor example.

require 'ruby-fann'
train = RubyFann::TrainData.new(
  inputs: [
    [0, 0], [0, 1], [1, 1], [1, 0]
  ], 
  desired_outputs: [
    [0], [1], [1], [0]
  ]
);

fann = RubyFann::Standard.new(num_inputs: 2, hidden_neurons: [10, 10, 10], num_outputs: 1)
fann.train_on_data(train, 1000, 10, 0.01) # 1000 max_epochs, 10 errors between reports and 0.1 desired MSE (mean-squared-error)

puts '0,0', fann.run([0, 0])
puts '0,1', fann.run([0, 1])
puts '1,0', fann.run([1, 0])
puts '1,1', fann.run([1, 1])

[tagliala]

It works for me, using @bnolan 's example above:

⚠️ Disclaimer ⚠️

I'm new to NN and I don't know enough of NN theory. In the following example, the input data set is very small and you should not run the NN against the training data. Also that training could fail, so you may need to repeat the process

require 'ruby-fann'

inputs          = [ [0, 0], [0, 1], [1, 0], [1, 1] ]
desired_outputs = [    [0],    [1],    [1],    [0] ] # proper XOR

hidden_neurons_number = ((inputs.first.size + desired_outputs.first.size) ** 0.5).round + 1

train = RubyFann::TrainData.new(inputs: inputs, desired_outputs: desired_outputs)

fann = RubyFann::Standard.new(num_inputs: 2, hidden_neurons: [hidden_neurons_number], num_outputs: 1)
fann.train_on_data(train, 1000, 10, 0.01) # 1000 max_epochs, 10 errors between reports and 0.1 desired MSE (mean-squared-error)

inputs.each do |input|
  puts "#{input} => #{fann.run(input)}"
end

ruby nn_xor_test.rb
Max epochs     1000. Desired error: 0.0099999998.
Epochs            1. Current error: 0.2503120899. Bit fail 4.
Epochs           10. Current error: 0.2499401718. Bit fail 4.
Epochs           20. Current error: 0.2423011661. Bit fail 4.
Epochs           30. Current error: 0.1863817573. Bit fail 3.
Epochs           40. Current error: 0.1407767683. Bit fail 1.
Epochs           50. Current error: 0.0858674496. Bit fail 1.
Epochs           60. Current error: 0.0190158486. Bit fail 0.
Epochs           62. Current error: 0.0088274833. Bit fail 0.
[0, 0] => [0.03469912811834021]
[0, 1] => [0.9446454636507801]
[1, 0] => [0.8884668126782995]
[1, 1] => [0.09336504889216161]

$ ruby nn_xor_test.rb
Max epochs     1000. Desired error: 0.0099999998.
Epochs            1. Current error: 0.2500002086. Bit fail 4.
Epochs           10. Current error: 0.2500554621. Bit fail 4.
Epochs           20. Current error: 0.2129755616. Bit fail 3.
Epochs           30. Current error: 0.1599631906. Bit fail 3.
Epochs           40. Current error: 0.1051470712. Bit fail 1.
Epochs           50. Current error: 0.0148407854. Bit fail 0.
Epochs           52. Current error: 0.0080423718. Bit fail 0.
[0, 0] => [0.103887281802755]
[0, 1] => [0.9576252736384885]
[1, 0] => [0.9506385048123076]
[1, 1] => [0.11616178258391585]

[heri]

@tagliala how did you come to the formula for hidden_neurons_number?

Also why only a number? in the given example, it is an array [2, 8, 4, 3, 4]. I'm not sure how it relates to your formula

[tagliala]

@heri Sorry but as I mentioned before, I don't know enough of NN theory.

I've found that formula here

Also why only a number?

As far as I understand, single number: 1 layer

Multiple numbers: something like this

[heri]

@tagliala Thanks. It looks like the + 1 can be changed up to + 10 and also one needs to experiment with the number of hidden layers.

I have errors (more than 1_000_000 !) so I will experiment with different values to see if ruby-fann can work with my dataset.

Also what's not mentioned by others is that we need to choose carefully select the data features.

[git-steven]

On the latest release (2.0), this returns acceptable values:

[0, 0] => [0.04931549037519472]
[0, 1] => [0.9527720517354428]
[1, 0] => [0.9503237704923142]
[1, 1] => [0.038072909787401965]

The XOR network test in RubyFannFunctionalTest (test_training_xor) also returns acceptable values, although it uses a sigmoid_symmetric activation function; hence the values of -1.0 and +1.0 .