Artificial Intelligence

I've been reading a number of articles on A.I. Here are some useful links:

Wikipedia: Machine Learning - The design and development of algorithms and techniques that allow computers to "learn"

Wikipedia: Computational Learning Theory - mathematical field related to the analysis of machine learning algorithms

Wikipedia: Learning to Learn - Applying knowledge gained from one problem or task to a different but related problem or task. For example, learning to walk could be used in learning to run, or learning to recognize cars could be used in learning to recognize trucks. (More info is needed on this topic)

Wikipedia: Alife - simulating life and intelligence

Wikipedia: Digital Organism (Bot) - Self-replicating computer program that mutates and evolves.

A.I. Systems Integration - Making individual software components interoperable with other components to create larger, broader and more capable A.I. systems.

Wikipedia: Agent Communication Language - Proposed standard language for agent communications

• Knowledge Query and Manipulation Language (KQML)
• FIPA-ACL
  

Example Environments

Breva - Build 3D simulations of decentralized systems and artificial life. Uses a language called Steve. (website)

DarwinBots - a virtual environment in which a number of "bots" interact, fight for resources, and eventually reproduce and evolve

• Downloads and Screenshots
  
• Example Bot
  

Evolve - Allows the user to create simulations, run them, and watch the evolving creatures.

• Blog
• Official Site

Technosphere - Users build their own creature, modular type of AI. This was very interesting and I'd like to follow up on it.


Ideas

Create an Agent Framework that uses REST and XML protocols

Don't and Do

I was reading an interesting book, Forget Selling: 12 Principles of Influence and Persuasion in Sales, Leadership, and Life by Edie Raether, There was an interesting statement in it.

Technically the brain can not distinguish between a do and don't statement. This is because don't is not a noun so we do not visual it. (See you just tried to visual it, even when I said don't)

Don't think about the elephant.

Don't smoke

This is a sneaky way to persuade someone into doing something. Place the thought in their head and come back around to it.

Notes on Reading Stock Chart

Regular Chart Patterns - Learn them

Please note: I am not a financial advisor, take all you read here with a grain of salt.

Head and Shoulders - picture

Signals that the price will make a downward move after having moved up in past periods.

Inverse Head and Shoulder signals the opposite

Cup and Handle - picture

Signals that the price will continue in an upward direction after the handle after having moved down in past periods.

Pattern should be a nicely rounded formation, similar to a semi-circle.

The valley should be between one-third and two-thirds the size of the previous upward movement

Double Top, Double Bottom - picture

Sometimes called "Twin Peaks"

Double Top (M) - Signals a downward direction change after moving up in past periods

Double Bottom (W) - Signals an updated direction change after moving down in past periods

Symmetrical Triangle - picture

Signals a consolidation to a given price. Once consolidated it may move in original direction, but it can go in the opposite direction.

Ascending Triangle - picture

Triangle shape, the top of the triangle will be straight. Each "side" of the triangle should be "tested"/"touched" multiple times.

Signals the price is to take an upward direction.

The optimum point to get in on this is right before it moves above the top of the triangle.

Descending Triangle signals the exact opposite.

Wedge - picture

Looks a lot like the symmetrical triangles, however they tend to last over longer periods of time.

Good Question: What's the difference between a wedge and a triangle

Gap - picture

A gap doesn't signify much as far as price trending, other then drastic changes in price.

Triple Top - picture

Trend has to test the same limit 3 times

Trend has to fall to the same support 2 times

Each test of limit will be marked with declining volume

Signals a downward direction

Triple Bottom - picture

Trend has to test the same limit 3 times

Trend has to fall to the same support 3 times

Signals an upward direction

Be careful as this looks just like Triple Top but signals an upward trend.

References:

Investpedia

Random Links for Week of 07.31

Some random links from round the web:

• Teach Kids to Program - Scratch is a simple web based platform which makes it easy to learn programming.

• Creating a valued Blog - Very interesting article on how to create a profitable blog space.

• Using Code Review for Interviews - Using code reviews to help weed out people during interviews.

• Create Draggable CSS Windows - A simple way to implement draggable windows using scriptlicious.

• SitePoint - Request a design, list a price, watch the masses compete.

• Search for Code - A few different search engines that specialize in finding source code.
  

SQL Server 2005 maximum limits

Ever wonder what the limits are for Sql Server properties....

Here you go

CSS XRay

This is a very cool utility that allows you to view the CSS properties of any object within your browser.

XRAY

Random Link: Foxmarks

Allows you to sync bookmark across different computers.

If you use Firefox on more than one computer, you'll want Foxmarks. Install Foxmarks on each computer, and it will work silently in the background to keep your bookmarks synchronized. As a bonus, log in to my.foxmarks.com from any computer anywhere to access your bookmarks.

Creating AI - Who Knows

In the last article I talked about a program that would learn like a new born baby. This article may or may not make sense if you have not read the last one.

For a new born baby life consists of inputs, actions and expectations. I have already discussed inputs. I would like to discuss actions and expectations.

The actions that a new born can take are fairly limited. It can cry, coo, sleep and poop. Breaking those into generalities; a baby gives negative and positive feedback, recharges and discharges.

SideBar: For the sake of my sanity we will leave pooping and discharging out of the rest of this conversation. (Let's act older then 6 here boys and girls)

Our "Baby Program" has the ability to give negative feedback, *waaa*, and positive feedback, *coo*, so far so good. Now comes the hard part deciding when to do what.

When does a new born make it's first choice? When it first realizes it's hungry of course. The baby's belly begins to hurt and then he needs to do something about it.

You could say that the baby is driven to want to be feed. And he is driven by the pain he feels.

Our "Baby" program has no built in wants. In addition to this is has no built in pains either. I believe we need to implement some more rules.

Our program will have one want, it wants to learn how to do things it has not done before. When it is not learning anything new it suffers from pain.

How will we implement this?

Rule: When there is no input, take an action (output) that you have no expectation for and perform it.

Rule: All actions (outputs) will have a reaction (input) associated with them.

Rule: Each time an reaction (input) is added to a reaction relationship it should strengthened that relationship.

Rule: Different inputs to the same outputs get linked as things that are alike.

Doing this will allow the program to learn or gain an expectation from an action. As a side rule we should note that if the program takes an action and gets no immediate input from the action, that is not saved as a reaction.

An Example Interaction:
> Baby: *waaa*

• Baby wants to learn something new, this is an action that he does not have an expectation for.

> User: What's wrong?

• At this point, the Baby adds saying "What's wrong?" to it's action list
• It also links "What's wrong" as a reaction to *waaa* with a strength of 0
  

> Baby: *cooo*

• Baby wants to learn something new, this is an action that he does not have an expectation for.

> User: Oh you like me, huh

• At this point, the Baby adds saying "Oh you like me, huh" to it's action list
• It also links "Oh you like me, huh" as an reaction to *cooo* with a strength of 0

So a million conversations go by....Baby never gets any relationship with a strength above 0 until one day someone repeats some thing that the Baby has heard before.

>Baby: Yo, how you doing?

> User: Oh you like me, huh

• Baby adds one to the relationship "*cooo*" -> "Oh you like me, huh"
  

Well I seemed to have gotten myself lost...maybe I will try this again soon.

Feel free to comment and help me out.

Creating AI - The Baby

In a previous post, I discussed an article I read which compares how humans think to how machines think. In the next set of posts I'm going to explore this concept a bit.

Sensory Input

It all starts with sensory input. So what sensory inputs does a program have? I can think of a number of them but I will limit myself to text for the time being. (I reserve the right to branch out though!)

Let's look at how a new born baby starts to recognize things. I think the first thing a baby recognizes is momma's milk. (some might say it's momma nipple, but let's keep it PG13, huh *hey geekboy get your mind out the gutter*)

A baby drinks milk for the first time, he doesn't know what it is but he knows he likes it. The taste and smell of milk gets stored in it's memory as well as the fact that he likes it. (Hey look it's a boy!) At this point life consists of smells and tastes that are milk and not milk. Anything that is milk he likes, the jury is out on anything else.

Following that logic, when the "baby" program encounters text it stores it in it's memory, however it knows nothing about it or what do with it.

Side Bar: It's important to note that the baby did not store multiple memories of the milk. Therefore the "baby" program will not store multiple versions of the same text.

Sounds simple so far...

Side Bar: I've always noticed that nature uses simplistic methods to create complex results, thus a side objective with this program is to keep the rules extremely simple.

With that in mind, the following logic is applied to all sensory packets that come into the program.

Each saved object will have a "goodness" attribute

If the program get a "bad" vibe from the object, subtract one

Otherwise add one to it's goodness attribute

I know, I know the brighter bunch of you are screaming...How does a program get a "BAD VIBE" this guys is full of .... Well hold on a second, put that issue to the side for a second, I promise I'll come back to that in the next session.

Using these rules what would the following set of inputs give me? Assuming that "b" gives a off a "bad vibe".

IN MEMORY
--------------------
a a: +1
a a: +2
a a: +3
b a: +3, B: -1
a a: +4, B: -1
b a: +4, B: -2
a a: +5, B: -2

OK, final step, we will now give the baby program two responses, one negative..."waaaa", and one positive *cooo*. Using the above mentioned rules interaction may look like the following:

IN OUT
--------------------
a *coooo*
a *coooo*
a *coooo*
b *waaaa*
a *coooo*
b *waaaa*
a *coooo*

At this point the baby progam has learned to like the letter "a" and dislike the letter "b"

Here is a basic summary of the rules our "Baby Program" follows:

Rule 1: Incoming text is saved and assigned a goodness value of 0

Rule 2: If text gives off a "bad" vibe from the object, subtract one

Rule 3: If text gives off a "good" vibe from the object, add one

Rule 4: If goodness value is positive, output *cooo*

Rule 5: If goodness value is negative, output *waaa*

The next section will go into how the "baby" program gets a good or bad vibe from input.

Random Links

Here's a detailed explanation of how to use css to create sprites from a sprite sheet.

If you don't know what that is, it's not for you.