associative_memory 0.2.0 → 0.2.1

data/README.rdoc

@@ -1,109 +1,111 @@
-# Associative Memory
+= Associative Memory
 
 http://dann.stayskal.com/software/associative_memory
 
-## Description
+== Description
 
 This is a ruby gem that lets you implement categorization systems with ease.
 
-**Associative memory neural networks** make it easy to identify probable patterns between sets of named data points.  It can be cumbersome to interface with the neural network directly, however, as a typical convergence matrix has a fixed size and training period, which limits how useful they can be to an integrated system.
+Associative memory neural networks make it easy to identify probable patterns between sets of named data points.  It can be cumbersome to interface with the neural network directly, however, as a typical implementation has a fixed size and training period, which limits how useful they can be to an integrated system.
 
-associative_memory simplifies these kind of machine learning models by offering dynamically configurable input and output sets, and a convergence model that adapts to the inputs you give it each time.  This allows your code to concentrate on extrapolating meaningful patterns rather than juggling bitmasks and transposition matrices.
+associative_memory simplifies these kind of machine learning models by offering dynamic input and output sets.  This allows your code to concentrate on extrapolating meaningful patterns rather than juggling bitmasks and transposition matrices.
 
-Under the hood, associative_memory implements a hetero-associative recurrent neural network designed according to Kosko's landmark paper (http://sipi.usc.edu/~kosko/BAM.pdf) establishing the model.  The model then dynamically rebuilds and adapts this network to accomodate new inputs as necessary.
+== Synopsis
 
-## Synopsis
+First, you'll want to tell associative_memory what you know about the set of things you're dealing with:
 
-First, you'll want to tell `associative_memory` what you know about the set of things you're dealing with:
+  require 'associative_memory'
+  @animals = AssociativeMemory.new
 
-	require 'associative_memory'
-	@animals = AssociativeMemory.new
-
-	@animals.associate([:tail, :fur, :legs, :paws], [:cats, :rats])
-	@animals.associate([:fins, :swimming], 			[:fish])
-	@animals.associate([:tail, :shell], 			[:turtles])
-	@animals.associate([:arms, :legs], 				[:humans])
-	@animals.associate([:swimming], 				[:humans, :rats, :turtles])
-	@animals.associate([:running], 					[:humans, :rats, :cats])
+  @animals.associate( [:tail, :fur, :legs, :paws], [:cats, :rats])
+  @animals.associate( [:fins, :swimming],          [:fish])
+  @animals.associate( [:tail, :shell],             [:turtles])
+  @animals.associate( [:arms, :legs],              [:humans])
+  @animals.associate( [:swimming],                 [:humans, :rats, :turtles])
+  @animals.associate( [:running],                  [:humans, :rats, :cats])
 
 Once you've done that, you can start asking it questions about patterns you've told it about:
 
-	running_things = @animals.describe([:running])
-	[:cats, :rats, :humans].each do |thing|
-		running_things.should include(thing)
-	end
-	@animals.describe([:humans]).should == [:arms, :legs, :running, :swimming]
-	@animals.describe([:swimming]).should == [:rats, :fish, :humans, :turtles]
-	@animals.describe([:tail]).should == [:cats, :rats, :fish, :turtles]
+  running_things = @animals.describe([:running])
+  [:cats, :rats, :humans].each do |thing|
+    running_things.should include(thing)
+  end
+  @animals.describe([:humans]).should == [:arms, :legs, :running, :swimming]
+  @animals.describe([:swimming]).should == [:rats, :fish, :humans, :turtles]
 
 Furthermore, it will be able to extrapolate patterns from data not explicitly taught:
 
-	@animals.describe([:fish]).should include(:tail)
+  @animals.describe([:fish]).should include(:tail)
 
 If you have more patterns to input, you can do it at any time:
 
-	@animals.associate([:jumping], [:humans, :rats, :cats])
-	@animals.describe([:humans]).should include(:jumping)
+  @animals.associate([:jumping], [:humans, :rats, :cats])
+  @animals.describe([:humans]).should include(:jumping)
 
-## Installation
+== Installation
 
 When using RVM:
 
-	$ gem install associative_memory
+  $ gem install associative_memory
 
 When using Bundler:
 
-	# Add to your Gemfile
-	gem "associative_memory"
+  # Add to your Gemfile
+  gem "associative_memory"
 
-	# Then install through Bundler
-	$ bundle install
+  # Then install through Bundler
+  $ bundle install
 
 Otherwise:
 
-	$ sudo gem install associative_memory
+  $ sudo gem install associative_memory
+
+== TODO
 
-## TODO
+* Implement detailed descriptions (likelihood of set membership based on non-bitmasked transpose products with the convergence matrix) (v.0.3)
+* Streamline network class with Matrix rather than Array (v.0.4)
+* Implement auto-associative neural network model (v.0.5)
 
-* Implement auto-associative neural network model (v.0.3)
-* Streamline network class with Matrix rather than Array
+== Maintenance
 
-## Maintenance
+Under the hood, associative_memory implements a hetero-associative recurrent neural network designed according to Kosko's landmark paper (http://sipi.usc.edu/~kosko/BAM.pdf) establishing the model.  The module then dynamically rebuilds and adapts this network to accomodate new inputs as they're presented.
 
 If you would like to help maintain or improve this gem, I welcome your patches. The build environment of this gem is streamlined for test-driven development using bundler, rvm, rspec, and guard.  To get it setup, you'll need to have Ruby Version Manager (http://beginrescueend.com/) installed, then do the following:
 
-	$ git clone git@github.com:danndalf/associative_memory
-	$ cd associative_memory
-	  # ...and accept the .rvmrc
-	  # have RVM build ruby 1.9 if necessary
-	$ gem install bundler
-	$ bundle install
-	$ bundle exec guard start
+  $ git clone git@github.com:danndalf/associative_memory
+  $ cd associative_memory
+    # ...and accept the .rvmrc
+    # have RVM build ruby 1.9 if necessary
+  $ gem install bundler
+  $ bundle install
+  $ bundle exec guard start
 
-Once guard starts, it will run through the full test suite.  After any changes are made to the libraries or specs, guard will re-run the relevant tests.  To re-run the full test suite, press enter at tie `> ` prompt in guard.  
+Once guard starts, it will run through the full test suite.  After any changes are made to the libraries or specs, guard will re-run the relevant tests.  To re-run the full test suite, press enter at the guard prompt.  
 
-After each test run, [simplecov](https://github.com/colszowka/simplecov) will generate a test coverage report in `coverage/index.html`.  This should show 100% coverage across all files when running the full test suite.
+After each test run, simplecov will generate a test coverage report in <code>coverage/index.html</code>.  This should show 100% coverage across all files when running the full test suite.
 
 If you would like to patch this gem:
 
 * Fork this repository
-* Write your tests
+* Write your tests (regression or unit tests)
 * Make your changes
-* Once all tests are passing and `simplecov` tells you all files are 100% covered, commit and push your changes
+* Once all tests are passing and all files have full test coverage, commit and push your changes
 * Send me a pull request
 * Wait for me to respond
 
 This will help me integrate your patch as quickly and reliably as possible.
 
-If you'd rather report a bug, please [open an issue on github](https://github.com/danndalf/associative_memory/issues).
+If you'd rather report a bug, please open an issue on github.
 
-## Resources
+== Resources
 
 * Support: http://dann.stayskal.com/software/associative_memory
 
-* Source code: http://github.com/danndalf/associative_memory
+* Source: http://github.com/danndalf/associative_memory
+
+* Bug Tracker: https://github.com/danndalf/associative_memory/issues
 
-## License
+== License
 
 This module is available under The MIT License.
 
@@ -115,7 +117,7 @@ a copy of this software and associated documentation files (the
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+rthe following conditions:
 
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.

data/lib/associative_memory.rb

@@ -2,7 +2,7 @@ require 'associative_memory/network'
 
 module AssociativeMemory
 
-	VERSION = '0.2.0'
+	VERSION = '0.2.1'
 	class << self
 
 		attr_accessor :associated_pairs, :network, :input_keyspace, :output_keyspace
@@ -88,4 +88,4 @@ module AssociativeMemory
 			self.network.matrix.map{|a| a.inspect}.join("\n") + "\n\n"
 		end
 	end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: associative_memory
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-25 00:00:00.000000000Z
+date: 2012-04-26 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &16462500 !ruby/object:Gem::Requirement
+  requirement: &27518280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.10'
   type: :development
   prerelease: false
-  version_requirements: *16462500
+  version_requirements: *27518280
 - !ruby/object:Gem::Dependency
   name: newgem
-  requirement: &16462040 !ruby/object:Gem::Requirement
+  requirement: &27517820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 1.5.3
   type: :development
   prerelease: false
-  version_requirements: *16462040
+  version_requirements: *27517820
 - !ruby/object:Gem::Dependency
   name: hoe
-  requirement: &16461600 !ruby/object:Gem::Requirement
+  requirement: &27517380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,27 +43,20 @@ dependencies:
         version: '3.0'
   type: :development
   prerelease: false
-  version_requirements: *16461600
+  version_requirements: *27517380
 description: ! 'This is a ruby gem that lets you implement categorization systems
   with ease.
 
 
-  **Associative memory neural networks** make it easy to identify probable patterns
-  between sets of named data points.  It can be cumbersome to interface with the neural
-  network directly, however, as a typical convergence matrix has a fixed size and
-  training period, which limits how useful they can be to an integrated system.
+  Associative memory neural networks make it easy to identify probable patterns between
+  sets of named data points.  It can be cumbersome to interface with the neural network
+  directly, however, as a typical implementation has a fixed size and training period,
+  which limits how useful they can be to an integrated system.
 
 
   associative_memory simplifies these kind of machine learning models by offering
-  dynamically configurable input and output sets, and a convergence model that adapts
-  to the inputs you give it each time.  This allows your code to concentrate on extrapolating
-  meaningful patterns rather than juggling bitmasks and transposition matrices.
-
-
-  Under the hood, associative_memory implements a hetero-associative recurrent neural
-  network designed according to Kosko''s landmark paper (http://sipi.usc.edu/~kosko/BAM.pdf)
-  establishing the model.  The model then dynamically rebuilds and adapts this network
-  to accomodate new inputs as necessary.'
+  dynamic input and output sets.  This allows your code to concentrate on extrapolating
+  meaningful patterns rather than juggling bitmasks and transposition matrices.'
 email:
 - dann@stayskal.com
 executables: []