Topic awaiting preservation: Messing with AI and colours (Page 1 of 1)

First, I haven't forgetten about the translucency thing. I've had some pretty good successes, but I'm still not quite happy. When I get there, you'll be the first to know.

A long time ago I was into Lisp and basic AI. For some reason, my interest in AI has been resparked. The AI that I've been messing with is node and weight based. I've messed with it before, but never quite this deep.

Basic neuron to play with in applet form:
Artificial Neuron Applet
Some of the applets are absent, but the good one seems to still work.
That is the node model that I've been playing with.

Notice that the output can be modified. The output method that I'm using is a sigmoidal function:

output = 1 / (1 + e^( input/p ))

Where e is approximately 2.7183 or, more accurately, exp(1).
And p is a way to control the curve.
As p approaches 0, the graph becomes more step-like.
Or, for p>1, the "relaxed" the graph becomes.
(I had a graphic to show this, but it looks like I've lost it. Bummer.)

Once you understand a basic node, you start slapping them together.
There are commonly 3 layers of nodes: input, hidden, and output.
Each hidden node is weighted to each input node.
Each output node is weighted to each hidden node.

Here is a crappy example that I did real quick: possible game AI nodes
Man, that really is a crappy example for several reasons. For one, I didn't show that the nodes should be sigmoidalified - even the input nodes.

Now, game programming isn't something I know terribly well. So I decided to go with pixels. Besides, pixels gives me a lame excuse to post this here. I'm a bad man.

For my first test, I went very basic.
Set up the nodes, randomize the weights, and randomize the thresholds/bias.
Inputs are x and y (pixel position).
There are two hidden nodes.
One output, which is parlayed into a shade of grey.



At first, I didn't think I was getting much of anything. However, a raw data dump was showing otherwise. So I took the rastor output into PS and auto leveled it. Turns out that I was getting very interesting gradients. Nothing fancy, but still interesting. I even took 3 of the more interesting ones and did a cut-n-paste for a comp RGB example.

With that simple test, I learned quite a bit about scaling. With a few minor adjustments, I was getting better results more frequently. Still not as good as I would have liked, but definitely better.

Time for a test with more nodes.
Inputs: x, y, x+y, and x-y.
Hidden nodes: 3
Output: R, G, and B.
Total of 10 nodes.



Ended up getting some pretty nifty gradients.
Again, auto leveled.

Time to take it up one more notch.

Okay, two photos for basic input.
That's RGBx2 for 6 input nodes.
Tossed in 4 hidden.
Finally 3 output for R, G, and B.



I know that it doesn't look like much that can't already be done with just PS. I'm sure most of you have done such things when getting crazy with blending modes and adjustment layers.

So, what good is all of this?

I'm still kind of working on that.
I do have some ideas, but I'm not sure if they will pan out.

Most of what you just said was over my head, and yet I found it very interesting.

How are you taking the same network and getting different results out of it? Are you modifying the weights in various nodes?


 

May your kids never keep you up this late.

Sorry about that, Slime.
Every time I click the button, everything is re-randomized.
That is, the weights and thresholds.
I will probably add a way to dump the weights/thresholds to file and load 'em up again.
You know, keep what is interesting and junk the rest.
This will also give a way to customize the weights/thresholds.

I'm getting the hang of this scalling thing.
Scalling the RGB inputs down to -2 to 2 is working fairly well.

Playing with this, I am astounded by some of the outputs.
In most outputs, I can see a little bit of at least 2 different blending modes with some kind of funky layer masking going on.
Not to mention the shifts in hue.

If I can get some more functionality in this lastest prog, I'll release it to ya'll to play with.

I've got way too much junk running around in my head.

Amost have the program presentable. Just a few more things to change and it should be all good. Although, it won't have much of anything in the way of error checking.

Not too long ago I was playing with Neuron Viewer. It's a lot of fun to sit and watch. There is one example in there that does edge detection. The set up is a node per pixel deal. Then, each pixel/node stimulates the surrounding nodes in the next layer.

Of course, I got to thinking about it last night while the kids were driving me nuts.
Using that particular model, you can do very smart convolutions.
That is, Custom Filter but way smarter... so to speak.
Have one matrix of weights, then a matrix of thresholds on the next level.
I think I'm going to take a whack at this next.

(Edited by warjournal on 06-10-2004 00:02)

colourai3.zip ~55k

colourai3.exe - the executable
sampleG2.jpg - Girlie #2
sampleBC.jpg - Biker Chic
sampleRM.jpg - pencil sketch of Red Monika

When started, sampleG2.jpg and sampleBC.jpg should load into the input picture slots.
The slots are 200x200 and will clip anything bigger.
Click either Load button to load another picture to the appropriate slot.

Click Combine to run the process.

By default, Auto Random is turned on.
Everytime you click Combine, the weights and thresholds will be re-randomized if Auto Random is on.

Randomize All
This will re-randomize the weights and threshholds using the ranges.

Input Scale
This scales 0-255 down to the number range.
By default, -4 to 4.
To see how Input Scale affects the process, turn Auto Random off, change either From or To, and click Combine again.
Personally, I like to stay between -8 and 8.

P
This affects the sigmoidal function.
Numbers closer to zero will have a posterizing effect.
"Larger" numbers will kind of wash out.
A negative number will do kind of an invert thing. Kind of an invert thing. It's weird as it seems to also operate on detail. Weird.
Do not use 0 or else you will get a division by zero error and crash.
To see how this affects the process, turn off Auto Random, change P, and click Combine.
Personally, I like to stay between 0.2 and 3.

When Randomizing -
The weights and thresholds will be randomized between From and To.
I like to stay between +/- 8, but I have tried as high/low as +/- 20.

Error Checking -
There is none.
Stick to numbers or you will get an error and crash.
You might crash if you do other things.
I don't even know if it will run on your machine.
Probably a good idea to keep all From values negative.
And probably a good idea to keep all To values positive.

Misc -
PC. Sorry Mac folks.
VB6, so might be a bit slow. It's what I have and I'm not afraid to use it.

Now, if you'll excuse me, I'm going to go die.

(Edited by warjournal on 06-10-2004 06:17)

And here i was getting away from exams...And what do I find? Sigmoidal functions, weights and bias-es all over again
Damn neurons...but I guess it kinda qualifies for an insane asylum after all
Anyway, WJ, great work, I've always meant to look on the other side of PS, with my scarce notions of C/C++ and Matlab, maybe I'll play with image manipulation (the do-it-your-self-part) too

Curiously yours, crip

Crip, go for it! I could always use the company.
I've heard a few stories about some folks using Matlab to do some pretty neat things. I remember one person talking about using Matlab to make some spiffy D-Maps. She was making D-Maps that had exponential and logarimic functions. Gotta love that.

For the first time in my life, I'm starting to regret not getting serious with any other programming language. I've dabbled with others, but always stuck with some flavor of basic. I mean, the sheer amount of number crunching is killer in VB.

Okay, while I did write the program to combine two photos, I didn't quite understand what was going on. So, I decided to go with some controlled experiments.

New doc 200x200.
Linear grad with black on left and white on right.
Save to jpeg.
Linear grad with black across the top and white along the bottom.
Save to jpeg.
Load 'em up and fiddle around.

Across the top are examples "as is" - all numbers are default and I did not Auto Levels in PS.

What we are getting is kind of 2 dimensional Gradient Map.
If Input1 is between a certain range and Input2 is between a certain range, then output a certain colour.
See? It's 2d while a G-Map is 1d.

Fascinating.



Along the bottom is a slightly different story.
Lower-left is "as is" with p=0.5.
Then I turned off Auto Random and changed p to -0.5.
While there is a striking similiarity between the two, it's not exactly a straight invert. Notice that the detail has also changed a little bit.

Wow. Heh.

Gotta go.

WJ, a question
I might be missing something, but how do you actually take the inputs as RGB and how do you output as RGB in the end?
I mean how do you read the images to give data to the neurons?
And second, are you doing this with only VB?

Curiously yours, crip

Basic is a pretty high language. You know, made to make programming easier on the brain. So the "bigger" the program, the slower it runs compared to an assembly written and compiled counterpart. Visual Basic is even higher than regular Basic. With VB, you can cobble together simple programs in almost no time at all with little brain power, but it comes at a price (the price is usually negligible, but starts to show with massive amounts of number crunching.).

I'm loading the input pictures into picture box controls.

picInput2.Picture = LoadPicture(CommonDialog1.FileName)

Something like that when using commond dialog controls to load a different picture.

A picture box has a method for reading individual pixels.

bigcolour1 = picInput1.Point(i, j)

It will come back as a long, so it will have to be pulled apart into seperate RGB values.
I snagged some functions for this.

colours(1, 1) = longred(bigcolour1)

colours(1, 2) = longgreen(bigcolour1)

colours(1, 3) = longblue(bigcolour1)

and, for example...

Public Function longgreen(xgreen As Long) As Long

   longgreen = ((xgreen And &HFF00) / 256&) Mod 256&

 End Function

Now I have RGB in the 0-255 range. That won't do as input into input nodes.
So, the 0-255 range is scaled to something more managable.
These are user defined in the above program (colourai3.exe); the default range is -4 to 4.

Let the nodes do their business, and you get 3 different outputs in the 0-1 range.
Scale it back up to 0-255.

outputR = int(outputNode(1) * 255)

I did the whole program in one day.
Spent 1/2 day getting it to work to my satisfaction, then another 1/2 day making it more presentable.
My programs are for my use only, so I don't bother with a lot of the little things (error checking being a big thing I leave in the dust).
This is actually the first time in my 20 years of programming that I have released a program.

Yes, VB6 only.
I'm kind of torn on learning a different language.
Right now I can cope with the speed, but it just won't do if I get even more serious.
Then again, I just want to mess around right now (proof of theory) instead of waiting to learn a new language.
I've already got a C/C++ book, so I might head in that direction.
Either way, I've got to get a book on WinAPI.

I've already started my next one.
Hopefully it will be interesting.

If I could make a small sugestions. If you are going to continue working on educational pieces like this I would stay away from the proprietary windows api. I would reccomend using something like gtk, qt or even the opengl (it does 2d as well) api. This way you can not only satisfy those who use windows but you can make some programs that us people without windows can appreciate as well. And C/C++ is a good language to learn, a bit more complex but well worth the time.

As for the project, I see pretty pictures, but I don't understand a lot of the math you are talking about. You are using the sigmoidal function and chaining them together to produce the end result? I think I am lost on the discussion of the nodes or how they work. Is it that you are supplying scalar values, and then plugging them through these nodes as different weights to transform the values into resultant scalars?

Each input is then given a weight and supplied to one or more hidden nodes to be computed? The result is then sent to one of the output nodes and what? are the results added together?

Sorry if I am being really dense, I just have some problems understanding complex math.

Hope I'm not teaching something you know, warmage. It's pretty simple.



The artificial neuron is a mathematical entity characterized by an input, x , 2 parametres, w and b, which are weight and bias , an activation function, d, and an output, y.

As you can see from the pic, y=f(x). the output will change in someway, accordingly tot he way x changes. But if you see that + block, it makes u=w*x+b .
And so, y=f(u)=f(w*x+b).
The actual form of the f function is left to our choice, but usualy the standard functions are used, as step, log-sigmoidal or tan-sigmoidal.
And so y=d(w*x+b). See? No hard math needed.
Now, why do we use these? I use them for automation control, or learn how to use them actually .
They can be arranged in 'networks', this is why they are called neurons, when the output of one neuron becomes the input of the next. The structure of the networks you use determines the way the whole network behaves. Networks are used because they can 'train' them selves to do a job once you set an expected output for them to produce, they will adapt themselves to do that.
That's about it .

Hope it serves someone, in this ...damn, PS forum LOL

Curiously yours, crip

(Edited by crip on 06-11-2004 19:03)

edit: that would make a good sig actually

(Edited by crip on 06-11-2004 19:06)

Alright, this is driving me nuts. I can't sleep and I'm ignoring the housework. And the girlies are getting minimum attention. Not from working on this at my machine, but my brain working overtime on this all by itself. I can't concentrate on anything else, and that's not good.

WarM, crip pretty much nailed it. Not the way I would have put it, but that's it. I might to my own write up on nodes and networks and things. You know, warjournalify the concepts and some of the techy stuff.

I've done a lot of rebuilding my framework. I'm almost to the point to were I can whip out a bunch of different AI progs with recycled code.

One thing that I'm thinking of is extraction. In my fiddlings, I've made a few observations, and I'm fairly positive that "smart" extraction is viable. If I can figure out back-propagation, then I'll be very happy.

Crip, do you understand back-propagation?
I might have to toss you an e-mail... or maybe start another thread over in the coding section.

Explained as a neuron I understand it completely.

So the entire system that WJ is using is a neuron? This makes things a whole lot easier to understand if I am correct in my assumption.

Actually, a network of neurons. Each one is just a smaller part of a whole bunch, or ganglia if that works for you.
There is a bunch of them to accept input.
Each one of those is connected to another bunch of neurons, called the hidden layer.
Then the hidden neurons are connected to a bunch of output neurons.

Try this: http://www.ai-junkie.com/nnt1.html

The monsters have arrived.
For me, the party is over for a few days.

edit:
sig be gone
damn it

(Edited by warjournal on 06-13-2004 00:11)

WK, my email is cripkd@ker.ro
And i wrote you some messages on icq too.

Curiously yours, crip

In theory, everything should be working.
Just a simple 3 input, 3 hidden, and 1 output.
You know, taking RGB and converting to greyscale.

All of a sudden, I'm getting funky errors.
For example, my sigmoidal function is occassionally overflowing.
Also, my long2RGB functions are returning -1 on occassion. Not good.

This is one of those weird places to be at.
Been staring at the code for so long, you don't even notice the changes that you've made moments before, then start second-guessing yourself because of it. Is it w(i,j) or w(j,k) that goes in that for next loop? Didn't I just change that?
Then there is figuring out how to dump such massive amount of raw data, not to mention shifting through it.
Pinning down those crazy shifts in numbers and why they are occurring is never fun.
Then there are those silly little logic bombs. Goes back to the w(i,j) or w(j,k) thing.
All it takes in one misplaced variable that you can't see and you are up all night sifting through dumps and eyeballing the tracers.

Ever miss a quote at the end of an HREF?
Like that, except *much* worse.

Shit.
The stuff I do.
I need a vacation from my brain.

warjournal: If you want I could create a simple wrapper to use SDL. Stuff like load image, getpixel,setpixel,etc

That's if you're interested in using c(++).

The nice thing is then it'll compile on mac/win32/linux/others

I figured out some of the problem that I've been having with backpropagation. Turns out I was training the nodes into the ground. As soon as I toned down the training, I was actually some results. Still got more to figure out, though.

Thanks for the offer, Nin, but C/C++ is a ways off for me. I don't have a problem with syntax and learning the functions and all that, but the "higher" concepts are so alien to me. When I made the jump from Basic to VB, I had the hardest time with event-driven. With C/C++, I'm going to have to come to grips classes, OOP, morphism (amorphism?), and things. Even though I'm an old time programmer, these paradigm shifts are hard on my brain. Talk about twisted karma.

When I get there, we'll see what's what.
But don't hold your breath.

I went out and grabbed the MS C/C++ compiler. You can get the compiler for free, but it comes without the Visual part. No big deal, right? Plus it comes with a bunch of includes and crap that I didn't want to have to hunt down. However, I'm having some compiling problems. I'll probably end up grabbing another free compiler and then using the extra includes that came with the MS compiler.

Okay, I've some limited success with backpropagation. At first, I was getting some major funkiness. For example, my sigmoidal function was going out of range. I was like, WTF? Turns out that backpropagation was running the weights far away from 0. Once I toned down the training, I was getting better results.

As much as I would like to use backpropagation, I'm going to give it up for now. I mean, I still don't totally understand the process and I don't like messing with someone elses code when I don't totally understand what's going on. Know what I mean?

So, the new question became: how do desaturate an image with nodes and weights? Not just for me, but in a way that makes sense and that others can use?

No easy answer.

First, the network is 3-3-1. That is: 3 input nodes, 3 hidden nodes, and an output node. So 3 * 3 + 3 = 12 weights. Then 4 or 7 thresholds depending on how lazy you are. Assuming the worst, that's 12 + 7 = 19 different numbers for the user to input. Gack!

Starting to see a problem here?

So, the sub-question became: how to "shorten" the process in a way that makes sense and still works?

While pondering, my mind kept wandering to Colour Mixer (CM). In CM, there are 3 main sliders when it pops up. Then there is the drop-down with more sets of sliders. CM has 3 * 3 = 9 sliders + Constant = 10 total. Not too shabby.

But the part about CM that really gets me is the 3 sliders per drop-down part. For each drop-down option, there are 3 sliders. Those 3 sliders are axis on a 3d colour cube. But even cooler than that is that they are counter-balanced, so to speak.

Grab some random photo in PS.
Bring up Colour Mixer.
Go to Green and zero the Green slider.
Go to Blue and zero the Blue slider.
Go back to Red.
Pump up G and B to 100 or so.
Now, grab the R slider and slide it past zero and into the negative.
What happens is that the negative R will counter the positive GB.

Very cool.

With that in mind, I also kept thinking about the colour dohicky in Painter. Man, the colour dohicky in Painter is cool. It's a colour wheel with a nifty triangle in it. By rotating the triangle and picking a spot in the triangle, you are actually defining a point in 3d space in a spiffy little gui. Very nice.

One of the points on the triangle is +sat and points at hue. The other two points are -lum and +lum, if you catch my drift. But what if they weren't those points persay? What if all 3 of those points were hue? Or even, what if each of those points was R, G, and B with offset? You know, like the Hue slider in HSB?

Eureka! Just input one value and rotate the other two!

Input angle theta
w(1,1) = cos(theta)
w(1,2) = cos(theta + 120)
w(1,3) = cos(theta - 120)

After a little number crunching and some basic tests, it was all looking good - very good. Suddenly I could knock down 3 inputs down to 1.

However, this brought up the problem of scale. The numbers would between -1 and 1, and that just wouldn't do. :sigh: Add another input for scaling. But still, knocking 3 down to 2 isn't too bad.

Just for the weights, that would take 4 x 3 = 12 down to 4 x 2 = 8. Then, just because they currently aren't entirely necessary, toss out the threshholds. Still at 8. Far cry from 19, eh? And so far it seems to be working fairly well.

A little more ironing to do and I should have something interesting to show.

Crap! I forgot a few things about the counter-balancing thing going on in the network. Bah, maybe next time.

quote:

---

I went out and grabbed the MS C/C++ compiler. You can get the compiler for free, but it comes without the Visual part.

---

For windows I recommend Dev-c++ 5 (Get the beta, it supports the standards a lot better and its pretty stable) If you want help getting it set up, you can send me an email.

(Edited by ninmonkey on 07-01-2004 17:53)

Thanks for the recommendation, Nin. I've grabbed it, but I have yet to play with it.

Here is a basic example of what I've been playing with:


On the left is what I've been desaturating. On the right is the basic result. That is actually two sets of controls in oppossition to each other. In this manner, they reinforce each other.

Now, I'm still doing the rotate the weights thing. Because of that, one set of controls will cause one hue to be white and the opposite hue to be black. So, if hue = 0 = white, then hue = 180 = black. Not sure if that's good, but it's cool.

However, the counter-balancing is kind of whack. Because the opposing hues are +120 and -120, there is this "bucked tooth" thing that happens with just one set of controls; hence, two sets of controls in oppossition for a cleaner example. The oppossing sets fill in the bucked tooth hole, as it were.

In the graphic that I've been desaturating, notice that black is along the bottom and that white is across the top. However, in the first desat example, those areas are turned into 50% grey. This has to do with sigmoidal and how I'm prepping the input. Also gets into saturation... long story. In a nutshell, sat = 0 = 50% grey.

To kind of fix that, I tossed in some basic lum controls. Check out the left side of this example:



The basic lum controls kind of act like Levels... kind of.

On the right in that example is the bucked tooth thing. Pretty nasty, huh?

Real example? Not to show, but I'll babble about it for a bit.
I'll use the funky colour graphic and tweak until I get a darker shade for blue and white stays white. Then I'll load up a photo of clouds and try it out. Sure enough: decent contrast between white clouds and blue sky.

Of course, always more things to work out and explore.
Of course, again, this goes back to something that has been in the back of my mind for a long time.
But I'll leave it at that for now.

iR is user input for Red being 0 to 1
iY is user input for Yellow being 0 to 1
same thing for iG, iC, iB and iM
these are user inputs

K = Max(RGB)

C = 255 - R ' might have to be 255 - R - K, but not sure
M = 255 - G
Y = 255 - B

Sat = ( Max(RGB) - Min(RGB) ) / 255 ' range is 0 to 1

Greyscale output =
iR * R * Sat +
iY * Y * Sat +
iG * G * sat +
. . .
K * (1 - Sat)

Just had to get that out because it's going to be awhile before I can test.

edit:
Crap.

M = 255 - G
Y = 255 - B

R = R - M - Y

I think...

edit2:
No.

edit3:
Flaw found. I'm an idiot.

(Edited by warjournal on 07-06-2004 07:21)

(Edited by warjournal on 07-06-2004 07:27)

(Edited by warjournal on 07-06-2004 07:39)

Captain Warjay's white whale has a logic bomb.

top:
Yellow translates just fine to greyscale. As do C and M.



bottom:
However, Green "bleeds" in a funky manner. R and B do this as well.

This is, with out a doubt, the worst logic bomb I have ever encountered.

anotheredit:
I'm pretty sure I found the logic bomb. This is something that I was previously wrestling with. You see, there is a difference between additive/subtractive and hue. I forgot about that difference for a bit. Hopefully I've got it. Let you know in a day or two.

yetanotheredit:
Yippie. The problem was the difference. Specifically, I was recycling some variables (R, G, & B) between the additive and hue routines. Silly me forgot to zero them out before heading off to hue. That is, the additive values were still being used. Silly, silly. silly.

Time to do some cleaning up. And it's lunch time.

(Edited by warjournal on 07-07-2004 17:16)

(Edited by warjournal on 07-07-2004 18:15)

(Edited by warjournal on 07-07-2004 18:24)

Warjournal would you like help with math and/or using c(++)? If you do, I'm ninmonkeysATyahooDOTcom If not i'd still like to take a look at your code/program to see what you're doing if you dont mind

Nin, I still have to get this thing out of my head. Fastest way right now is VB. :sigh: Once my head is cleared out, then I'll start focusing on C/C++.

The thing that I just did is only one layer of weights. This is, input > output. Rather straight-forward and rather linear. But it works and is something that I've wanted for a long time.

I'll comment the code and put some stuff together for you. It will be VB, but shouldn't be a problem in understanding what is going on.
Depending on my brain and the kids, might be a day or two.

Have you ever had a major revelation on the tip of your brain but you just couldn't realize the revelation even though you know it's there? That's the limbo that my head is in right now. Frustrating.

Time to disappear for a few days.

If I get caught sitting here, I'm so dead. But I've got quickie idea thing in my head.

A D-Map describes a vector for any given point.
Motion Blur works on a vector.
Combine the two.
Motion Blur that kinda goes around curves.

Basic idea, and expound.
Too many directions... hahaha.