First commit of the ANN Research Project!
-----------------------------------------

-This is a early working prototype of the project
-Works using boolean logic as test cases

-Also contains all files needed to set up the project
A second commit to test the repo
Lots of code has been rewritten for performance reasons, especially
cutting down on the number of function calls, and rewriting most of the
loops.
-Need to incorporate the error checking into the train method in order
to speed up the algorithm
-This also adds a data folder to contain each data file
Further optimized

-Still too slow; need to look into moving away from the OO approach
somewhat
More performance changes.
-Added ability to have multiple hidden layers
-Also cleaned up variable initializations that were created previously
as possible performance enhancers
	-In Python, the smallest variable scope is at the function level,
rather than inside loops, for example.  Therefore, if a variable is
first assigned within a loop, the variable name is added to the local
(function) scope, and can be accessed outside of the loop.  Therefore,
"initializing" local variables outside of loops does not increase
performance.
-A few more performance tweaks
-The "compute_network_output" function call in the train function has
been removed, and the function has been inlined for performance reasons.
	-Note: the "train" function is now quite large, however this is to
reduce function calls as this is a costly method
Major Update!
-Incorporated parallelization into the backpropagation training!!
	-Will scale to the number of cpu cores present to take full advantage
of all possible resources
	-Splits up the training data, copies the same network to each process
and then allows each process to train it's copy of the network on the
given subset of the training data. Then the process will return the
trained network on a queue to the master process, which will then
average out the weights from all networks for the final master network.
	=Results are often better than sequential training, and much faster
-Fixed a bug with parallel training
-Added another test set of data
Updates to network creation, and a few other minor changes
Working copy.  About to change the backprop algorithm
Backpropagation has been rewritten to follow the theory correctly,
resulting in more correct, and much faster learning

-Need to implement gradient checking still
-Resilient Prop is broken still
Introducing Klean: the NN research program!

-have finally added a script to the code so that it can be run with any
data, rather than the hardcoded data
	-this has been named "klean" for now
	-allows for network to be saved to a file and read in later
	-this has made main.py obsolete, other than for internal testing
-implemented by-hand gradient checking, in order to determine that the
previous update to the backpropagation algorithm was in fact correct.
This code is very costly, so it has been pulled out and placed in a text
file so as to not clutter up the main code
-RProp has been pulled for now as well
-Updated the data format so that instead of two lists, inputs & targets,
there is instead one list of examples, where example[0] is the target
vector, and example[1] is the input vector for each example in examples
Restructuring the project.
Also, there are a few small edits here and there, mainly just to comments
Renamed the project to "Pine" and restructured the project accordingly.

Also, moved the command line script to a bin/ folder, and cleaned up some of the rest of the project structure.
Restructuring the project a bit more.

Created a demo folder and placed demo.py within it, which was "main.py"
before.  It's has a bunch of stuff in it from testing the project during
the early stages.

Also updated some import statements.
Adding verbose option to the command line script
Verbose option added to Testing and Preditcting modes of the command line script
Adding info to the README file, and a small change to the old demo.
added license