16 5 / 2013

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.


  • 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.
  • Agent Action: Catalog and summarize all input variables and patterns within a parameter until all patterns are known. Exchange those patterns with other agents, or upload information to central databases.

09 3 / 2013

panbelacqua said: Hey, so I reblogged something of yours. Regarding working on a self-sufficient AI, I think you should propose the idea to Google. They're clearly interested, based on their hiring of Ray Kurzweil.

Thank you. I still need to flesh my ideas out a little more. I’ve posted an update of my thesis here. http://tmblr.co/ZSvSdxfj_npE

04 3 / 2013

23 2 / 2013

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

{-# LANGUAGE QuasiQuotes, TemplateHaskell, TypeFamilies, OverloadedStrings #-}
{-# LANGUAGE GADTs, FlexibleContexts #-}

import Database.Persist
import Database.Persist.Sqlite (withSqliteConn, runSqlConn, runMigration)
import Database.Persist.TH (share, mkPersist, mkMigrate, sqlSettings, persist)
import Control.Monad.Trans.Resource (runResourceT)

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persist|
Person                              -- Table name
    name String                     -- String value
    age Int Maybe                   -- Numerical value

main = runResourceT $ do
    -- adds name "Frank Silver" and age "40" data.db file
    updateDB "Frank Silver" 40
updateDB x y = withSqliteConn "data.db" $ runSqlConn $ do
	-- Creates "Person" table if one doesn't exist
    runMigration migrateAll      
	-- Inserts values into .db file
    insert $ Person x $ Just y

21 2 / 2013

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.

import Brain.Neuron (dendrite, axon, soma)

20 2 / 2013

The singularity isn’t going to happen if we just sit around and wait for it. There needs to be more of us working independently on pushing the evolution of artificial intelligence.

18 2 / 2013

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.

It’s all a matter of time.

(Source: tonysharp.me)

15 2 / 2013

(Source: tonysharp.me)

10 2 / 2013

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?

• Knowledge Discovery with Support Vector Machines by Lutz H. Hamel

(Source: tonysharp.me)

09 2 / 2013

"Our actions are merely the by-product of pre-programmed instincts, and consciousness is what happens when an organism acquires enough neurons to see itself."