Subtle Array

A foundation for an agent to act and evolve independently of human intervention using mathematically defined instincts, emulating the manner in which biological behaviors in nature evolve from the survival instinct. Outlined in three categories.

Instinct Modules

Instinct modules are comprised of desired states that define how an environmental pattern should be.

An environmental pattern is any element or entity that exists within an environment, including the environment itself.

Agent actions are initialized to fulfill desired states.

The agent will act upon the environmental patterns that are the focus of the instinct until a percentage of the desired state is reached.

Evolution

Create randomized variations of the agent actions.

If the variation improves the speed and energy usage of the action output, promote that variation to become the new default agent action for that instinct.

Instinct Modules

- Survival

Desired State: Maintain population.

Agent Action: Build copies of itself.

- Order

Desired State: Minimize entropy.

Agent Action: Catalog and offset internal and environmental disorder by repairing and avoiding internal and environmental damage.

- Knowledge

Desired State: Collect and exchange information.

I tweaked the sample code from the Yesod Book to make it a little easier for Haskell beginners to understand and use. You'll need to install the following packages from Cabal: persistent, persistent-sqlite, persistent-template

You're working on a huge Haskell project, and grouping your functions solely by modules is proving to be insufficient, so now you want to sort your modules into subdirectories.

Let's say you have a Main.hs file in your root folder /, and a Neuron.hs module in a subfolder called /Brain. You can access the functions in /Brain/Neuron.hs by adding the following line to Main.hs.

import Brain.Neuron

And if you only want to access a single function, called dendrite, from the module, you can write the line like this.

import Brain.Neuron (dendrite)

Additional functions can be added, separated by commas.

The only reasonable arguments I've heard against the creation of conscious machines is that the brain is physically too different and biologically resilient to be built using the hardware we currently have, or could have, and that the processes of the brain are too random to predict, therefore they can't be replicated. But both of these arguments have massive flaws.

Just as we didn't need to copy a bird feather-by-feather to create an airplane, we won't need to replicate or understand every cell of the brain to create a mind. There's nothing magical or immaterial about the brain. It receives inputs, returns outputs to itself, creates new inputs, and then returns outputs to the outside world. It's nothing more than a complex math problem.

And the brain's resilience against physical damage is a hardware problem that'll likely be solved in the future by the people working on hardware. But the mind is just software, and even today we can do something called "hot-swapping" with languages like Erlang where chucks of code can be removed and replaced without having to stop the system.

Ruling out conscious machines without any foreknowledge of the future is a shortsighted view that one can only have by ignoring the exponential grown of technology. 100 years ago who could have guessed that we’d have pocket-sized computers that can understand basic natural language, or cars that can drive themselves?

Technology isn’t going to stop evolving, and there’s no reason to believe that we won’t be able to recreate the algorithms of the brain in software form within the next 100 years.

Practical Algebra: A Self-Teaching Guide by Peter H. Selby

Forgotten Calculus by Barbara Lee Bleau

Statistics in Plain English by Timothy C. Urdan

Probability Theory: The Logic of Science by E. T. Jaynes

Linear Algebra by Jim Hefferon [PDF]

Convex Optimization by Boyd & Vandenberghe [PDF]

[Video] Learning from Data: Freely available Caltech course

What was the motivation for this tutorial?

This tutorial is my attempt to present the SVMs in a way so that anyone with a passing knowledge of computer science can understand and use it.

What is a support vector machine?

A support vector machine is a supervised machine learning algorithm used for data classification and estimating the relationships between variables (regression analysis). It’s a “supervised” algorithm because there’s an initial training phase involved where you feed the algorithm data that has already been classified (labeled). After this initial training phase is completed, future data sets given to the algorithm can be classified with no or minimal human intervention.

What are the advantages of using a support vector machine?

Many learning algorithms can only do linear classification, using a straight line to separate the data points. But there are algorithms, support vector machines being one of them, that can also do non-linear classification using a kernel method.

A kernel method, in short, is an equation that can pull data points apart into 3-dimensional space, and, instead of using a line as a separator, it uses something called a hyperplane, that, from a vertical standpoint, can take nonlinear forms. Nonlinear classification provides a more sophisticated way to classify complex data sets that can't easily be separated by a straight line.

What’s the fastest way to get started with support vector machines?

There are several software packages and libraries available that you can use. Two of the most popular are Rapid Miner and libsvm.

How do I use libsvm?

• For Windows: Download and extract the libsvm zip file, and move the windows files into the folder where your data files are located. • For Ubuntu Linux: Enter sudo apt-get install libsvm-tools into the Terminal. • In the command line (cmd in Winndows, Terminal in Linux), run the svm-train executable on your training data (ex. a1a. / rename this file to a1a.train for convenience) to create a model of your data. Use example: svm-train a1a.train • Run the svm-predict executable on test data (ex. ata.t / rename this file to a1a.test for convenience) and on the model file created by svm-train. End the command with the name of the predictions output file you’d like for it to create. Use example: svm-predict a1a.test a1a.train.model a1a.out • The 1 and -1 classification labels in the output file correlate with the order of the data entries in the test file, and were learned from the training file.

Where should I go if I want to learn more?

A simple program for comparing data sets with different algorithms. Replace the data in the data.db file with your own data using an sqlite3 manager. Tables are read as data set names, and the values are read as the data points of the data sets. Load the application, choose an algorithm, and the program will find the pairs that best match each other.

Written with Haskell. Currently Linux only.

After a lot of hard work and whining I finally know enough Haskell to write a program. This wouldn't have been possible without the help of Stack Overflow, the Haskell IRC, and these outstanding books.

A lot of people prefer Learn You A Haskell by Miran Lipovača, but I found Programming in Haskell to be a lot more clear and concise. It quickly covers just the information a beginner needs to develop a solid Haskell foundation.

Real World Haskell picks up where Programming in Haskell leaves off. It goes into more detail on how to use monads (a clever abstract data type for safely handling side effects), and how to develop complete working programs.

Pearls of Functional Algorithm Design demonstrates how to develop and optimize algorithms using the functional programming approach / "design by calculation." Very good math porn.

Great video series on functional programming.

The human mind is likely comprised of 2 minds in 1. The first mind observes and deduces meaning from its environment, and the second observes and deduces meaning from what the first mind has drawn. So you essentially have a mind watching the world, and another watching the first (or itself).

How does one create this in machine form?

This is easier said than done, but here's the idea.

We first create an AI software that deduces meaning and patterns from its environment using the latest and greatest machine learning algorithms. We equip a robot with 2 copies of this software. The first copy will be the "low level AI" that uses the world for its input, and the second will be the "high level AI" that draws its input from the first AI.