It's actually deceivingly simple.

Each automata starts with a single bit on. Think of it as an
ever-expanding table with rows and columns, and the first state is a
1x1 table with one on bit. The next row would have 3 columns, the next
5, then 7, etc. Each new row has 2 more elements than the last, new
elements being added on the right and left of the structure.

The "rule" for the automata defines it's behavior. For example, I've
been talking about Rule 30, which I think is best explained by this
image:

http://mathworld.wolfram.com/images/eps-gif/ElementaryCARule030_1000.gif

Each cell within a new row depends on the state of the three cells
above it (top left, top center, top right). Those cells decide whether
the current cell is "on" or not.

There are 256 possible rules for this type of cellular automata,
because there are 8 possible states to be evaluated (2^8 == 256). Some
rules don't to anything interested at all, but a handful of them
generate spectacularly interesting behavior (notably rule 30 [1], rule
90 [2], rule 110 [3] among others).

If you're still confused, the algorithm I've written to generate
automaton is under 100 lines of code:
https://github.com/rhyolight/automatatron/blob/master/automatatron/engine.py

[1] http://mathworld.wolfram.com/Rule30.html
[2] http://mathworld.wolfram.com/Rule90.html
[3] http://mathworld.wolfram.com/Rule110.html

---------
Matt Taylor
OS Community Flag-Bearer
Numenta


On Sun, Jan 18, 2015 at 3:11 PM, cogmission1 .
<[email protected]> wrote:
> I did, and I read it. I just don't get how the patterns start and progress,
> how one line becomes another line, or how a rule is used to produce the next
> pixel - or whatever the hell is happening. That article explains things as
> if you are someone who's seen it before, which is useless if starting from
> nothing.
>
> On Sun, Jan 18, 2015 at 4:51 PM, Matthew Taylor <[email protected]> wrote:
>>
>> David, didn't you see the document I linked in my first email?
>>
>> http://mathworld.wolfram.com/ElementaryCellularAutomaton.html
>>
>> The idea was popularized by Stephen Wolfram in "Celluar Automata and
>> Complexity"[1] and the (presumptuously) titled "A New Kind of
>> Science"[2]
>>
>> The intriguing thing about the ideas is that a very simple set of
>> rules can generate very complex pseudo-random behavior that mimic some
>> natural processes. Some cellular automata rules are actually used as
>> random number generators.
>>
>> [1]
>> http://www.amazon.com/Cellular-Automata-Complexity-Collected-1-2150-/dp/0201626640/ref=sr_1_4?s=books&ie=UTF8&qid=1421621337&sr=1-4&keywords=stephen+wolfram
>> [2]
>> http://www.amazon.com/New-Kind-Science-Stephen-Wolfram/dp/1579550088/ref=sr_1_1?s=books&ie=UTF8&qid=1421621337&sr=1-1&keywords=stephen+wolfram&pebp=1421621340100&peasin=1579550088
>>
>> ---------
>> Matt Taylor
>> OS Community Flag-Bearer
>> Numenta
>>
>>
>> On Sun, Jan 18, 2015 at 2:22 PM, cogmission1 .
>> <[email protected]> wrote:
>> > *knock, knock*
>> >
>> > uh oh, the Nerd Police are at my door shouting, "Mr. Ray, your geek card
>> > has
>> > been revoked!"
>> >
>> > On Sun, Jan 18, 2015 at 4:19 PM, cogmission1 .
>> > <[email protected]>
>> > wrote:
>> >>
>> >> Uhm... can you pleez esplain (for us dummies)? I don't get the
>> >> progression
>> >> or how the rules are used and what they result in?
>> >>
>> >> On Sun, Jan 18, 2015 at 3:31 PM, Matthew Taylor <[email protected]>
>> >> wrote:
>> >>>
>> >>> If anyone wants to play around with it, I've created a python project
>> >>> that can create all elementary cellular automaton easily.
>> >>>
>> >>> https://github.com/rhyolight/automatatron
>> >>>
>> >>> It's truly amazing to me that only about 80 lines of python code can
>> >>> create the whole library of ECAs. It's a testament to the idea that a
>> >>> very simple ruleset can create extraordinarily complex behavior.
>> >>>
>> >>> You can currently use a handler function to get iteration output rows,
>> >>> but I'm going to have to add the ability to stream a subset of columns
>> >>> from a running automata so specific columns can be pushed into NuPIC
>> >>> instead of the entire output (as soon as I find time).
>> >>>
>> >>> ---------
>> >>> Matt Taylor
>> >>> OS Community Flag-Bearer
>> >>> Numenta
>> >>>
>> >>>
>> >>> On Sun, Jan 18, 2015 at 2:18 AM, Fergal Byrne
>> >>> <[email protected]> wrote:
>> >>> > Hi Matthew,
>> >>> >
>> >>> > This would be a great demo (Wolfram's CA stuff appeals to most of us
>> >>> > nerds).
>> >>> > I predict that if you feed a fixed set of bits into NuPIC, the TM
>> >>> > will
>> >>> > learn
>> >>> > the rule you've picked and will be able to predict the next pattern
>> >>> > for
>> >>> > all
>> >>> > but the edge bits (which will be partly random as far as it can
>> >>> > tell).
>> >>> > I'd
>> >>> > also predict that a single-order TM (one cell per column) will be
>> >>> > also
>> >>> > able
>> >>> > to do this learning.
>> >>> >
>> >>> > These two predictions come directly from the CLA theory (Subutai can
>> >>> > verify
>> >>> > this), so it could be a good integration test for new
>> >>> > implementations
>> >>> > (assuming NuPIC matches my predictions, of course!).
>> >>> >
>> >>> >
>> >>> > Regards,
>> >>> >
>> >>> > Fergal Byrne
>> >>> >
>> >>> > On Sat, Jan 17, 2015 at 10:23 PM, Jeff Fohl <[email protected]> wrote:
>> >>> >>
>> >>> >> I used to be a bit of a cellular automata nerd. I would be
>> >>> >> interested
>> >>> >> in
>> >>> >> seeing what you discover. You could also possibly just feed in the
>> >>> >> values
>> >>> >> for the center column of rule 30 - though that has been shown to be
>> >>> >> highly
>> >>> >> random, so I am not sure what the utility of it would be?
>> >>> >>
>> >>> >> - Jeff
>> >>> >>
>> >>> >> On Sat, Jan 17, 2015 at 1:59 PM, Matthew Taylor <[email protected]>
>> >>> >> wrote:
>> >>> >>>
>> >>> >>> I've always been fascinated by elementary cellular automata [1].
>> >>> >>> Some
>> >>> >>> rules produce interesting pseudo-random patterns with repeating
>> >>> >>> features. I think it would be interesting to see if NuPIC can
>> >>> >>> decipher
>> >>> >>> these features from the randomly generated output of the automaton
>> >>> >>> and
>> >>> >>> predict the continuation of partially-developed features. I also
>> >>> >>> wonder what the anomaly scores would say after NuPIC has seen
>> >>> >>> several
>> >>> >>> thousand rows of data.
>> >>> >>>
>> >>> >>> I've put together a *very* simple program [2] to generate the
>> >>> >>> output
>> >>> >>> of Rule 30 [3], but I did it in JavaScript out of habit. I really
>> >>> >>> need
>> >>> >>> it implemented in Python to get decent integration with NuPIC.
>> >>> >>>
>> >>> >>> To feed cellular automaton data into NuPIC, I assume I'll need to
>> >>> >>> choose some number of adjacent columns within the automatons'
>> >>> >>> output
>> >>> >>> (maybe 10 fields?). Each field would be simply binary, and I've
>> >>> >>> got
>> >>> >>> some code in place now that can extract the columns and print them
>> >>> >>> to
>> >>> >>> the console [4].
>> >>> >>>
>> >>> >>> Is anyone else interested in this crackpot idea? I have no idea
>> >>> >>> what
>> >>> >>> any applications might be, I'm just fiddling around. Let me know
>> >>> >>> if
>> >>> >>> you're interested and we can discuss.
>> >>> >>>
>> >>> >>> [1] http://mathworld.wolfram.com/ElementaryCellularAutomaton.html
>> >>> >>> [2] https://github.com/rhyolight/cellular-automata-engine
>> >>> >>> [3] http://en.wikipedia.org/wiki/Rule_30
>> >>> >>> [4] http://youtu.be/TT2-aXrmJ6k
>> >>> >>>
>> >>> >>> Regards,
>> >>> >>> ---------
>> >>> >>> Matt Taylor
>> >>> >>> OS Community Flag-Bearer
>> >>> >>> Numenta
>> >>> >>>
>> >>> >>
>> >>> >
>> >>> >
>> >>> >
>> >>> > --
>> >>> >
>> >>> > Fergal Byrne, Brenter IT
>> >>> >
>> >>> > http://inbits.com - Better Living through Thoughtful Technology
>> >>> > http://ie.linkedin.com/in/fergbyrne/ -
>> >>> > https://github.com/fergalbyrne
>> >>> >
>> >>> > Founder of Clortex: HTM in Clojure -
>> >>> > https://github.com/nupic-community/clortex
>> >>> >
>> >>> > Author, Real Machine Intelligence with Clortex and NuPIC
>> >>> > Read for free or buy the book at
>> >>> > https://leanpub.com/realsmartmachines
>> >>> >
>> >>> > Speaking on Clortex and HTM/CLA at euroClojure Krakow, June 2014:
>> >>> > http://euroclojure.com/2014/
>> >>> > and at LambdaJam Chicago, July 2014: http://www.lambdajam.com
>> >>> >
>> >>> > e:[email protected] t:+353 83 4214179
>> >>> > Join the quest for Machine Intelligence at http://numenta.org
>> >>> > Formerly of Adnet [email protected] http://www.adnet.ie
>> >>>
>> >>
>> >>
>> >>
>> >> --
>> >> We find it hard to hear what another is saying because of how loudly
>> >> "who
>> >> one is", speaks...
>> >
>> >
>> >
>> >
>> > --
>> > We find it hard to hear what another is saying because of how loudly
>> > "who
>> > one is", speaks...
>>
>
>
>
> --
> We find it hard to hear what another is saying because of how loudly "who
> one is", speaks...

Reply via email to