neuro_gammon 0.7.0

data/lib/neuro_gammon/board_tools.rb

@@ -0,0 +1,46 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require 'neuro_gammon/board'
+
+module NeuroGammon
+  module BoardTools
+    
+    def reverse_state state
+      #first reverse all the colours (except the bar)
+      new_state=[]
+      new_state[0]=[]
+      new_state[1]=[]
+      state[0].each_index do |i|
+        new_state[0] << state[0][i]*-1
+      end
+      
+      state[1].each_index do |i|
+        new_state[1] << state[1][i]
+      end
+      
+      new_state[0].reverse!
+      new_state[1].reverse!
+      return new_state
+    end
+    
+    def test_for_gammon state,colour
+      on_bar= (colour==Board::WHITE ? state[1][0] != 0 : state[1][1] != 0)
+      on_board= state[0].find() {|x| x*colour>0}
+      return false if (on_board or on_bar)
+      blank=state.flatten.find {|x| x!=0}.nil?
+      return false if blank 
+      if state[1].find() {|x| x!=0}
+        return false if colour==Board::WHITE ? state[1][0]!=0 : state[1][1]!=0
+      end
+      
+      range=colour==Board::WHITE ? (18..23) : (0..5)
+      return range.find(){|x| state[0][x]*(-colour) > 0} == nil
+      
+    end
+    
+    
+    
+  end
+end

data/lib/neuro_gammon/dice.rb

@@ -0,0 +1,60 @@
+# 
+#     Copyright (C) 2008  Stuart Owen
+# 
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+# 
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+# 
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module NeuroGammon
+  class Dice
+    
+    def initialize
+      @values=[]
+      roll
+    end
+    
+    def roll
+      @values=[]
+      @values << rand(6)+1
+      @values << rand(6)+1
+      check_state
+    end
+    
+    def double?
+      @double
+    end
+    
+    def [] x
+      return @values[x]
+    end
+    
+    def to_a
+      @values
+    end
+    
+    def each
+      to_a.each {|obj| yield(obj)}
+    end
+    
+    def use! value
+      #TODO is there a method on Array to delete one value only?
+      i=@values.index(value)
+      raise Exception.new("No value " << value << " in dice " << self.to_a.to_s) if i==nil
+      @values.delete_at(i)
+    end    
+    
+    def check_state
+      @double=(@values[0]==@values[1])    
+      @values = double? ? Array.new(4,self[0]) : @values
+    end
+  end
+end

data/lib/neuro_gammon/fann_player.rb

@@ -0,0 +1,116 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+require 'neuro_gammon/base_neural_player'
+require 'rubygems'
+require 'ruby_fann/neural_network'
+require 'neuro_gammon/board_tools'
+require 'tempfile'
+
+module NeuroGammon  
+  
+  class FannPlayer < BaseNeuralPlayer
+    include BoardTools
+    
+    def initialize
+      super
+    end
+    
+    def cascade_learn! games
+      corpus=generate_corpus games
+      training_data=RubyFann::TrainData.new(:inputs=>corpus[0], :desired_outputs=>corpus[1])
+      @net.cascadetrain_on_data(training_data,5,5,0.0004)
+      store_net_data
+    end
+    
+    def learn! games
+      corpus=generate_corpus games
+      training_data=RubyFann::TrainData.new(:inputs=>corpus[0], :desired_outputs=>corpus[1])
+      @net.train_on_data(training_data,1500,30,0.0004)
+      store_net_data
+    end
+    
+    def to_yaml_properties
+      ["@n_inputs","@n_outputs","@hidden_layers","@learning_rate","@net_data"]
+    end
+    
+    def self.from_yaml yaml
+      obj=YAML::load(yaml)
+      class << obj
+        def pub_read_net_data
+          read_net_data
+        end
+      end     
+      obj.pub_read_net_data
+      obj
+    end     
+    
+    #see store_net_data
+    def read_net_data
+      f=Tempfile.new("fann-net-in")
+      f.write(@net_data)
+      f.flush      
+      @net=RubyFann::Standard.new(:filename=>f.path)
+      f.close
+    end
+            
+    protected
+    
+    def run_net input
+      return @net.run(input)
+    end
+    
+    def evaluate_output output,board,dice,colour
+      score=0
+      if (colour==Board::WHITE) 
+        score = output[0]-output[2]
+        score += 2*(output[1]-output[3])
+      else
+        score = output[2]-output[0]
+        score += 2*(output[3]-output[1])
+      end
+      return score
+    end
+    
+    def generate_input_pattern board_state
+      pattern=[]
+      board_state.flatten.each do |v|
+        pattern << v
+      end
+      return pattern
+    end
+    
+    def generate_output_pattern board_state,game
+      result=[-1,-1,-1,-1]
+      if test_for_gammon(board_state,game.winner_colour)
+        game.winner_colour==Board::WHITE ? result[1]=1 : result[3]=1
+      end
+      game.winner_colour==Board::WHITE ? result[0]=1 : result[2]=1
+      return result
+    end
+    
+    def init_net
+      @n_inputs=26
+      @n_outputs=4
+      @hidden_layers=[300]
+      @learning_rate=0.4
+      @net=RubyFann::Standard.new(:num_inputs=>n_inputs,:hidden_neurons=>hidden_layers,:num_outputs=>n_outputs)
+      # @net.set_training_algorithm :incremental
+      @net.set_learning_rate(learning_rate)
+      store_net_data
+    end
+    
+    #this is required to store the binary of the @net, for YAML conversion. 
+    #since ruby-fann only seems to like saving to and from a file, this is created by saving the net to a tmp file, then reading back in
+    def store_net_data
+      f=Tempfile.new("fann-net-out")
+      @net.save(f.path)      
+      f2=open(f.path)     
+      @net_data=f2.read
+      f.close
+    end
+    
+    
+  end
+end

data/lib/neuro_gammon/game.rb

@@ -0,0 +1,44 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+module NeuroGammon
+  class Game
+    attr_accessor :winner_colour
+    attr_reader :board_states
+    attr_reader :dice_states
+    attr_reader :moves
+    attr_reader :black_player
+    attr_reader :white_player
+    attr_reader :colour_moved
+    
+    def initialize white_player,black_player
+      @black_player=black_player
+      @white_player=white_player
+      @board_states=[]
+      @moves=[]
+      @dice_states=[]
+      @colour_moved=[]
+    end
+    
+    def add_board_state state
+      self.board_states << Marshal.load(Marshal.dump(state))
+    end
+    
+    def add_dice_state dice
+      dice_states << Marshal.load(Marshal.dump(dice))
+    end
+    
+    def add_move move
+      moves << Marshal.load(Marshal.dump(move))
+      #TODO test for a valid range for coming on and bearing off, throw Exceptions otherwise, and harden unit tests for this
+      if move[0]==-1 #come on
+        colour_moved << (move[1]>17 ? Board::WHITE : Board::BLACK)
+      elsif move[1]==-1 #bear off
+        colour_moved << (move[0]<=5 ? Board::WHITE : Board::BLACK)
+      else
+        colour_moved << (move[0]-move[1]>0 ? Board::WHITE : Board::BLACK)
+      end
+    end
+  end
+end

data/lib/neuro_gammon/game_engine.rb

@@ -0,0 +1,75 @@
+# 
+#     Copyright (C) 2008  Stuart Owen
+# 
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+# 
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+# 
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'neuro_gammon/board'
+require 'neuro_gammon/dice'
+require 'neuro_gammon/game'
+
+module NeuroGammon
+  class GameEngine
+    attr_accessor :board
+    attr_accessor :dice
+    attr_accessor :colour
+    attr_reader :black_player,:white_player
+    attr_reader :game_data
+    attr_reader :winner
+    
+    def initialize white_player,black_player
+      @board=Board.new
+      @dice=Dice.new
+      @black_player=black_player
+      @white_player=white_player
+      @colour=Board::WHITE
+    end
+    
+    def play_game
+      game=Game.new white_player,black_player
+      while !(board.piece_count(Board::BLACK)==0 || board.piece_count(Board::WHITE)==0)
+        dice.roll
+        while dice.to_a.size>0
+          game.add_dice_state(dice.to_a)
+          game.add_board_state(board.state) #TODO final board state isn't recorded (i.e. always ends with 1 piece remainining)
+          player=player_to_move
+          move=player.suggest_move(board,dice,@colour)
+          if (move!=nil) 
+            board.move!(move,colour,dice)
+            game.add_move(move)
+          else #can't move
+            #TODO this needs some more careful thought, and unit tests. Do we want to record when a move couldn't be made??
+            game.dice_states.delete(game.dice_states.last)
+            game.board_states.delete(game.board_states.last)        
+            break
+          end
+        end
+        toggle_player
+      end
+      game.winner_colour=board.winner
+      @winner=(board.winner==Board::WHITE ? white_player : black_player)
+      
+      return game
+    end
+    
+    private
+    
+    def player_to_move
+      @colour==Board::BLACK ? black_player : white_player
+    end
+    
+    def toggle_player
+      @colour=(@colour==Board::BLACK ? Board::WHITE : Board::BLACK)
+    end
+  end
+end

data/lib/neuro_gammon/lazy_player.rb

@@ -0,0 +1,25 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+#always picks the first move avaliable - just for testing really
+
+require 'neuro_gammon/base_player'
+
+module NeuroGammon
+  class LazyPlayer < BasePlayer
+    def initialize
+      super
+    end
+    
+    def suggest_move board,dice,colour
+      valid=board.valid_moves(colour, dice)
+      if (valid.size>0)
+        move=valid.first
+        return move
+      else
+        return nil
+      end
+    end
+  end
+end

data/lib/neuro_gammon/random_player.rb

@@ -0,0 +1,38 @@
+# 
+#     Copyright (C) 2008  Stuart Owen
+# 
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+# 
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+# 
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'neuro_gammon/board'
+require 'neuro_gammon/dice'
+require 'neuro_gammon/base_player'
+
+module NeuroGammon
+  class RandomPlayer < BasePlayer
+    def initialize
+      super
+      
+    end
+    
+    def suggest_move board,dice,colour
+      valid=board.valid_moves(colour, dice)
+      if (valid.size>0)
+        move=valid[rand(valid.size)]
+        return move
+      else
+        return nil
+      end
+    end
+  end
+end

data/nbproject/private/rake-t.txt

@@ -0,0 +1 @@
+(in C:/Users/sowen/Documents/NetBeansProjects/NeuralGammon)

data/nbproject/project.properties

@@ -0,0 +1,6 @@
+javac.classpath=
+main.file=main.rb
+ruby.includejava=false
+source.encoding=UTF-8
+src.dir=lib
+test.src.dir=test

data/nbproject/project.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+    <type>org.netbeans.modules.ruby.rubyproject</type>
+    <configuration>
+        <data xmlns="http://www.netbeans.org/ns/ruby-project/1">
+            <name>NeuralGammon</name>
+            <source-roots>
+                <root id="src.dir"/>
+            </source-roots>
+            <test-roots>
+                <root id="test.src.dir"/>
+            </test-roots>
+        </data>
+    </configuration>
+</project>

data/neuro_gammon.gemspec

@@ -0,0 +1,82 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{neuro_gammon}
+  s.version = "0.7.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Stu"]
+  s.date = %q{2010-08-04}
+  s.email = %q{sowen@stuzart.org}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     ".hgignore",
+     ".loadpath",
+     ".project",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "fred.net",
+     "lib/main.rb",
+     "lib/main2.rb",
+     "lib/neuro_gammon.rb",
+     "lib/neuro_gammon/base_neural_player.rb",
+     "lib/neuro_gammon/base_player.rb",
+     "lib/neuro_gammon/best_of_tournament_engine.rb",
+     "lib/neuro_gammon/board.rb",
+     "lib/neuro_gammon/board_tools.rb",
+     "lib/neuro_gammon/dice.rb",
+     "lib/neuro_gammon/fann_player.rb",
+     "lib/neuro_gammon/game.rb",
+     "lib/neuro_gammon/game_engine.rb",
+     "lib/neuro_gammon/lazy_player.rb",
+     "lib/neuro_gammon/random_player.rb",
+     "nbproject/private/rake-t.txt",
+     "nbproject/project.properties",
+     "nbproject/project.xml",
+     "neuro_gammon.gemspec",
+     "test/test_base_player.rb",
+     "test/test_board.rb",
+     "test/test_board_tools.rb",
+     "test/test_dice.rb",
+     "test/test_fann_player.rb",
+     "test/test_game.rb",
+     "test/test_game_engine.rb"
+  ]
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Neural Net Backgammon utility library - just a bit of messing about - nothing serious.}
+  s.test_files = [
+    "test/test_game_engine.rb",
+     "test/test_dice.rb",
+     "test/test_base_player.rb",
+     "test/test_board_tools.rb",
+     "test/test_fann_player.rb",
+     "test/test_game.rb",
+     "test/test_board.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<uuidtools>, [">= 2.1.1"])
+      s.add_runtime_dependency(%q<ruby-fann>, [">= 1.1.3"])
+    else
+      s.add_dependency(%q<uuidtools>, [">= 2.1.1"])
+      s.add_dependency(%q<ruby-fann>, [">= 1.1.3"])
+    end
+  else
+    s.add_dependency(%q<uuidtools>, [">= 2.1.1"])
+    s.add_dependency(%q<ruby-fann>, [">= 1.1.3"])
+  end
+end
+