tlearn 0.0.1

data/ext/tlearn/weights.c

@@ -0,0 +1,116 @@
+#include <stdio.h>
+
+extern	int	nn;	/* number of nodes */
+extern	int	ni;	/* number of inputs */
+extern	int	nt;	/* nn + ni + 1 */
+
+extern	long	tsweeps;	/* total sweeps */
+extern	long	sweep;		/* current sweep */
+
+extern	float	**wt;		/* (nn x nt): weights */
+extern	float	**dwt;		/* (nn x nt) delta weight at time t */
+extern	float	**winc;		/* (nn x nt) accumulated weight increment*/
+
+extern	char	loadfile[];	/* .wts file to start with */
+extern	char	root[];		/* root file name */
+
+
+save_wts()
+{
+
+	FILE	*fp;
+	FILE	*fopen();
+
+	register	int	i;
+	register	int	j;
+
+	float	*w;
+	float	**wp;
+
+	char	file[128];
+
+#ifdef ibmpc
+	/* 
+	 * if running under DOS, probably can't have filenames
+	 * with more than 8 chars total, or multiple "."s, so
+	 * "fileroot.nnnnn.wts" becomes "fileroot_nnnnn.wts"
+	 */
+	sprintf(file, "%s_%ld.wts", root, sweep);
+#else
+	sprintf(file, "%s.%ld.wts", root, sweep);
+#endif
+	if ((fp=fopen(file, "w+")) == NULL) {
+		perror("Can't open .wts file\n");
+		exit(1);
+	}
+	fprintf(fp, "NETWORK CONFIGURED BY TLEARN\n");
+	fprintf(fp, "# weights after %ld sweeps\n", sweep);
+	fprintf(fp, "# WEIGHTS\n");
+
+	/* to each node */
+	wp = wt;
+	for (i = 0; i < nn; i++, wp++){
+		fprintf(fp, "# TO NODE %d\n",i+1);
+		w = *wp;
+		/* from each bias, input, and node */
+		for (j = 0; j < nt; j++,w++){
+			fprintf(fp,"%f\n",*w);
+		}
+	}
+
+	fflush(fp);
+	fclose(fp);
+
+	return;
+}
+
+load_wts()
+{
+
+	FILE	*fp;
+	FILE	*fopen();
+
+	register	int	i;
+	register	int	j;
+
+	register	float	*w;
+	register	float	*wi;
+	register	float	*dw;
+	register	float	**wp;
+
+	int	tmp;
+
+	char	mode[10];
+
+	if ((fp=fopen(loadfile, "r")) == NULL) {
+		perror(loadfile);
+		exit(1);
+	}
+	fscanf(fp, "NETWORK CONFIGURED BY %s\n", mode);
+	if (strcmp(mode, "TLEARN") != 0) {
+		printf("Saved weights not for tlearn-configured network\n");
+		exit(1);
+	}
+	fscanf(fp, "# weights after %ld sweeps\n", &tsweeps);
+	fscanf(fp, "# WEIGHTS\n");
+
+	/* to each of nn nodes */
+	wp = wt;
+	for (i = 0; i < nn; i++, wp++){
+		fscanf(fp, "# TO NODE %d\n",&tmp);
+		w = *wp;
+		dw = *(dwt+i);
+		wi = *(winc+i);
+		/* from each bias, input, and node */
+		for (j = 0; j < nt; j++, w++){
+			fscanf(fp,"%f\n",w);
+			*dw = 0.;
+			*wi = 0.;
+		}
+	}
+
+	return;
+
+}
+
+

data/lib/tlearn.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.dirname(__FILE__) + '/lib')
+
+require 'tlearn/training_data'
+require 'tlearn/fitness_data'
+require 'tlearn/config'
+require 'tlearn/run_tlearn'
+
+require 'tlearn/run'
+
+def tlearn_extension
+  File.exists?(File.dirname(__FILE__) + '/tlearn.so') ? 'tlearn.so' : 'tlearn.bundle'
+end
+
+require tlearn_extension
+
+module TLearn
+end

data/lib/tlearn/config.rb

@@ -0,0 +1,101 @@
+module TLearn
+  class Config
+    WORKING_DIR = File.dirname(__FILE__) + '/../../data'
+    TLEARN_NAMESPACE = 'evaluator'
+    NUMBER_OF_RESET_TIMEPOINTS = 3497
+    DEFAULT_NUMBER_OF_SWEEPS = 1333000
+    
+    def initialize(config)
+      @connections_config = config[:connections] || {}
+      @special_config     = config[:special]     || {}
+      @nodes_config       = config[:nodes]       || {}
+    end
+
+    def setup_config(training_data)
+      File.open("#{file_root}.cf",    "w") {|f| f.write(evaulator_config(training_data))}
+    end
+
+    def setup_fitness_data(data)
+      File.open("#{file_root}.data",  "w") {|f| f.write(build_data(data))}
+    end
+
+    def setup_training_data(training_data)
+      File.open("#{file_root}.reset", "w") {|f| f.write(build_reset_config(training_data))}
+      File.open("#{file_root}.data",  "w") {|f| f.write(build_data(training_data))}
+      File.open("#{file_root}.teach", "w") {|f| f.write(build_teach_data(training_data))}
+    end
+    
+    def number_of_sweeps
+      DEFAULT_NUMBER_OF_SWEEPS
+    end
+
+    def file_root
+      "#{WORKING_DIR}/#{TLEARN_NAMESPACE}"
+    end
+
+    private
+
+    def connections_ranges_to_strings(connections_config)
+      connections_config.map{|hash| {hash.keys[0].to_s.gsub('..','-') => hash.values[0]}}
+    end
+
+    def evaulator_config(training_data)
+      nodes_config = {
+        :nodes => @nodes_config[:number_of_nodes],
+        :inputs => training_data.no_of_inputs,
+        :outputs => training_data.no_of_outputs,
+        :output_nodes => @nodes_config[:output_nodes]
+      }
+
+      @connections_config = connections_ranges_to_strings(@connections_config)
+
+      output_nodes = nodes_config.delete(:output_nodes)
+      node_config_strings = nodes_config.map{|key,value| "#{key.to_s.gsub('_',' ')} = #{value}" }
+      node_config_strings << "output nodes are #{output_nodes}"
+
+      connection_config_strings = @connections_config.map{|mapping| "#{mapping.keys[0]} from #{mapping.values[0]}" }
+      connection_config_strings =  ["groups = #{0}"] + connection_config_strings
+    
+
+      config = <<EOS
+NODES:
+#{node_config_strings.join("\n")}
+CONNECTIONS:
+#{connection_config_strings.join("\n")}
+SPECIAL:
+#{@special_config.map{|key,value| "#{key} = #{value}" }.join("\n")}
+EOS
+    end
+
+    def build_data(training_data)
+      data_file = <<EOS
+distributed
+#{training_data.no_of_data_values}
+#{training_data.data.map{|d| d.join(" ")}.join("\n")}
+EOS
+    end
+
+    def build_teach_data(training_data)
+      data_strings = training_data.output_data.map{|d| d.join(" ")}
+      data_strings = data_strings.each_with_index.map{|data, index| "#{index} #{data}" }
+      
+      teach_file = <<EOS
+distributed
+#{training_data.no_of_data_values}
+#{data_strings.join("\n")}
+EOS
+    end
+  
+    def build_reset_config(training_data)
+      reset_points = training_data.reset_points
+      reset_file = <<EOS
+#{reset_points.join("\n")}
+EOS
+    end
+    
+    def number_of_outputs(training_data)
+      training_data.values[0].length
+    end
+    
+  end
+end

data/lib/tlearn/fitness_data.rb

@@ -0,0 +1,24 @@
+module TLearn
+  class FitnessData
+    def initialize(data)
+      @data = data
+    end
+    
+    def reset_points
+      [0, 2]
+    end
+    
+    def data
+      [@data]
+    end
+
+    def no_of_data_values
+      1
+    end
+
+    def no_of_inputs
+      @data_list.length
+    end
+    
+  end
+end

data/lib/tlearn/run.rb

@@ -0,0 +1,29 @@
+module TLearn
+  class Run
+
+    def initialize(config, out=STDOUT)
+      @config = config
+      @out = out
+    end
+
+    def train(data, number_of_sweeps = nil)
+      run_tlearn = RunTLearn.new(@config)
+
+      results = run_tlearn.train(TrainingData.new(data), number_of_sweeps)
+      
+      if results
+        results.each{|r| @out.puts(r.inspect)}
+        results
+      else
+        @out.puts("[Error] Training failed") 
+      end
+    end
+
+    def fitness(data, number_of_sweeps = nil)
+      run_tlearn = RunTLearn.new(@config)
+
+      run_tlearn.fitness(FitnessData.new(data), number_of_sweeps)
+    end
+  
+  end
+end

data/lib/tlearn/run_tlearn.rb

@@ -0,0 +1,68 @@
+module TLearn
+  class RunTLearn
+    class UntrainedError < Exception; end;
+  
+    def initialize(config = {})
+      @config = Config.new(config)
+    end
+  
+    def fitness(data, number_of_sweeps = @config.number_of_sweeps)
+      raise UntrainedError.new("Train me first!") unless network_trained?
+
+      clear_previous_fitness_session
+
+      @config.setup_fitness_data(data)
+
+      execute_tlearn_fitness(number_of_sweeps)
+    end
+  
+    def train(training_data, number_of_sweeps = @config.number_of_sweeps)
+      clear_entire_training_data
+      
+      @config.setup_config(training_data)
+      @config.setup_training_data(training_data)
+
+      execute_tlearn_train(number_of_sweeps)
+          
+      if training_successful?(number_of_sweeps)
+        weights = File.read("#{Config::WORKING_DIR}/#{Config::TLEARN_NAMESPACE}.#{number_of_sweeps}.wts").split("\n")
+        `cp #{Config::WORKING_DIR}/#{Config::TLEARN_NAMESPACE}.#{number_of_sweeps}.wts #{Config::WORKING_DIR}/#{Config::TLEARN_NAMESPACE}.wts`
+        weights.map{|line| line.split("\t").map{|number| number.strip}}
+      else
+        false
+      end
+    end
+    
+    private
+    
+    def file_root
+      "#{File.expand_path(Config::WORKING_DIR)}/#{Config::TLEARN_NAMESPACE}"
+    end
+
+    def clear_previous_fitness_session
+      FileUtils.rm_f("#{file_root}.output")
+      FileUtils.rm_f("#{file_root}.reset")
+    end
+
+    def clear_entire_training_data
+      FileUtils.rm_f(Dir.glob("#{Config::WORKING_DIR}/*"))
+    end
+    
+    def training_successful?(number_of_sweeps)
+      File.exists?("#{file_root}.#{number_of_sweeps}.wts")
+    end
+
+    def network_trained?
+      File.exists?("#{file_root}.wts")
+    end
+    
+    def execute_tlearn_fitness(number_of_sweeps)
+      TLearnExt.fitness({:sweeps => number_of_sweeps, :file_root => file_root})
+    end
+  
+    def execute_tlearn_train(number_of_sweeps)
+      TLearnExt.train({:sweeps => number_of_sweeps, :file_root => file_root})
+    end
+
+  end
+end

data/lib/tlearn/training_data.rb

@@ -0,0 +1,41 @@
+module TLearn
+  class TrainingData
+    def initialize(data)
+      @data_list = data
+    end
+    
+    def reset_points
+      sum = 0
+      reset_times = @data_list.map do |data| 
+        sum = sum + data.length
+        sum
+      end
+      [sum, 0] + reset_times
+    end
+
+    def output_data
+      @data_list.reduce([]){|all_data, data| all_data + data.
+        reduce([]){|data_list, data_hash| data_list << data_hash.values[0] }
+      }
+    end
+
+    def data
+      @data_list.reduce([]){|all_data, data| all_data + data.
+        reduce([]){|data_list, data_hash| data_list << data_hash.keys[0] }
+      }
+    end
+    
+    def no_of_data_values
+      @data_list.map{|data| data.length}.reduce(&:+)
+    end
+
+    def no_of_inputs
+      @data_list[0][0].keys[0].length
+    end
+    
+    def no_of_outputs
+      @data_list[0][0].values[0].length
+    end
+      
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: tlearn
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joseph Wilk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-19 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- joe@josephwilk.net
+executables: []
+extensions:
+- ext/tlearn/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/tlearn/config.rb
+- lib/tlearn/fitness_data.rb
+- lib/tlearn/run.rb
+- lib/tlearn/run_tlearn.rb
+- lib/tlearn/training_data.rb
+- lib/tlearn.rb
+- ext/tlearn/activate.c
+- ext/tlearn/arrays.c
+- ext/tlearn/compute.c
+- ext/tlearn/Exp/exp.c
+- ext/tlearn/getopt.c
+- ext/tlearn/parse.c
+- ext/tlearn/subs.c
+- ext/tlearn/tlearn.c
+- ext/tlearn/tlearn_ext.c
+- ext/tlearn/update.c
+- ext/tlearn/weights.c
+- ext/tlearn/extconf.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ruby bindings for tlearn
+test_files: []