---

From: neat@yahoogroups.com [mailto:neat@yahoogroups.com] On Behalf Of Ken
Sent: Sunday, November 22, 2009 3:38 PM
To: neat@yahoogroups.com
Subject: [neat] Re: F# NEAT

 

Jeff, makes sense, thanks for the clarification. By the way, I think there is a little confusion with people's names: There are two different "Kens" who have been talking to you. So actually it was Ken Lloyd who made the point about parallelism. I'm Ken Stanley, and I didn't actually make that point, although it makes sense.

ken

--- In neat@yahoogroups.com, Jeff Haynes <feedyurhed@...> wrote:
>
> Ah, no, sorry, just meant that I thought NEAT was the best approach to
> neuroevolution to date. I don't have any good reason to suspect that F# is
> particularly well suited to it. I think I agree with you that the parallel
> extensions are the best approach. There was talk at PDC about the use of
> agents in F# to accomplish parallelism across different boxes. But there's
> no support for that yet and I don't see any reason that the same concepts
> wouldn't be applied to C# or the other languages when/if they show up. Of
> course, it's probably just all the marketing hype that I've been exposed to
> talking, but MS was pushing Azure (their cloud solution) very hard this
> year. It's tempting to imagine writing a version of NEAT that could run on
> Azure. Has the potential for exposing vast computing resources for
> relatively little coin. Of course, at this point, if you were going to
> develop something for Azure (or something similar), there are better
> languages than F# (probably C# for Azure and java for just about anything
> else - amazon EC2, hadoop, etc).
>
> - Jeff
>
>
> On Sun, Nov 22, 2009 at 5:19 PM, Ken <kstanley@...> wrote:
>
> >
> >
> >
> >
> > Jeff, I'm not familiar enough with F# to judge whether it is well-suited
> > for NEAT or not. However, I was curious what you meant when you said,
> > "Always thought NEAT was our best chance for success." Is there something
> > you wanted to accomplish with NEAT that you feel F# would make more
> > realistic to accomplish?
> >
> > ken
> >
> >
> > --- In neat@yahoogroups.com <neat%40yahoogroups.com>, Jeff Haynes
> > <feedyurhed@> wrote:
> > >
> > > Hey Ken, thanks for the note. Yeah, I agree that the parallel extensions
> > > are a good alternative. I am definitely not more comfortable in
> > declarative
> > > languages (I'm impressed by anyone who is). I was sitting in a session on
> > > F# at PDC at the time so I guess I was amped up on F# :). We're still
> > > trying to figure out the performance trade-offs between the different
> > > languages (taken in combination with the kernel and architecture changes
> > > we've seen, it's not clear). There was a time when I would have said (did
> > > say) that C++ was the only language for NEAT. However, the advances are
> > > impressive. At any rate, hope you can get back to this at some point!
> > > Always thought NEAT was our best chance for success.
> > >
> > > Cheers,
> > >
> > > Jeff
> > >
> > >
> > > On Thu, Nov 19, 2009 at 3:29 PM, Ken Lloyd <kalloyd@> wrote:
> > >
> > > >
> > > >
> > > > Hi Jeff,
> > > >
> > > > F# tends to be declarative, which is fine if that paradigm is more
> > > > comfortable for you. There are .NET Extensions for Parallel Processing
> > if
> > > > you wish to stay with .NET and object-oriented approaches, say for
> > > > SharpNEAT. Intel has its Parallel Studio, and gives good insight into
> > C++
> > > > HyperNEAT.
> > > >
> > > > The whole issue of partitioning of tasks and data for parallel
> > processing
> > > > is interesting when applied to NEAT - or any genetic-inspired
> > computation.
> > > > I've been experimenting on various fabrics for massively parallel
> > > > computation (on GPUs, for example) for HyperNEAT. So far, I've had some
> > > > successes, but sometimes absolute failures, too.
> > > >
> > > > I've been pulled off my neuroevolution projects for more mundane (read:
> > > > money making) tasks. Hopefully, I can get back to them very shortly.
> > > >
> > > > Ken Lloyd
> > > > Watt Systems Technologies Inc.
> > > >
> > > > ------------------------------
> > > > *From:* neat@yahoogroups.com <neat%40yahoogroups.com> [mailto:
> > neat@yahoogroups.com <neat%40yahoogroups.com>] *On Behalf Of *Jeff
> > > > Haynes
> > > > *Sent:* Thursday, November 19, 2009 12:56 PM
> > > > *To:* neat@yahoogroups.com <neat%40yahoogroups.com>
> > > > *Subject:* [neat] F# NEAT
> > > >
> > > >
> > > >
> > > > Hi, I've been quiet on this group for a long time although I've kept my
> > > > subscription so I remember to play with NEAT once I have free time
> > > > (presumably retirement). I've been tossing around the idea in my head
> > for
> > > > some time of doing an implementation of NEAT in F#. For the
> > uninitiated, F#
> > > > is MS's functional .NET solution to the manycore system. It is
> > completely
> > > > interoperable with C#/VB and can use the .NET framework. I'm still
> > getting
> > > > completely ramped up on it but it seems like it might be very well
> > suited to
> > > > NEAT. I was wondering what people think about this. Waste of time?
> > Maybe
> > > > NEAT would be better suited to hadoop or something like that. Maybe
> > > > something like this has already been done. Anyway, I welcome thoughts.
> > > > Thanks,
> > > >
> > > > Jeff
> > > >
> > > > --
> > > > ...imagine a puddle waking up one morning and thinking, 'This is an
> > > > interesting world I find myself in, an interesting hole I find myself
> > in,
> > > > fits me rather neatly, doesn't it? In fact it fits me staggeringly
> > well,
> > > > must have been made to have me in it!' This is such a powerful idea
> > that as
> > > > the sun rises in the sky and the air heats up and as, gradually, the
> > puddle
> > > > gets smaller and smaller, it's still frantically hanging on to the
> > notion
> > > > that everything's going to be alright, because this world was meant to
> > have
> > > > him in it, was built to have him in it; so the moment he disappears
> > catches
> > > > him rather by surprise. I think this may be something we need to be on
> > the
> > > > watch out for.
> > > >
> > > > -- Douglas Adams
> > > >
> > > >
> > > >
> > >
> > >
> > >
> > > --
> > > ...imagine a puddle waking up one morning and thinking, 'This is an
> > > interesting world I find myself in, an interesting hole I find myself in,
> > > fits me rather neatly, doesn't it? In fact it fits me staggeringly well,
> > > must have been made to have me in it!' This is such a powerful idea that
> > as
> > > the sun rises in the sky and the air heats up and as, gradually, the
> > puddle
> > > gets smaller and smaller, it's still frantically hanging on to the notion
> > > that everything's going to be alright, because this world was meant to
> > have
> > > him in it, was built to have him in it; so the moment he disappears
> > catches
> > > him rather by surprise. I think this may be something we need to be on
> > the
> > > watch out for.
> > >
> > > -- Douglas Adams
> > >
> >
> >
> >
>
>
>
> --
> ...imagine a puddle waking up one morning and thinking, 'This is an
> interesting world I find myself in, an interesting hole I find myself in,
> fits me rather neatly, doesn't it? In fact it fits me staggeringly well,
> must have been made to have me in it!' This is such a powerful idea that as
> the sun rises in the sky and the air heats up and as, gradually, the puddle
> gets smaller and smaller, it's still frantically hanging on to the notion
> that everything's going to be alright, because this world was meant to have
> him in it, was built to have him in it; so the moment he disappears catches
> him rather by surprise. I think this may be something we need to be on the
> watch out for.
>
> -- Douglas Adams
>

Hi all,

Maybe a wiki would be just the ticket here?

Cheers,

Evert


On 23 Nov 2009, at 00:07, dkuppitz wrote:

> Hello Ken,
>
> here's just another vote for a tutorial, with the difference that I
> would prefer it for HyperSharpNEAT.
>
> It would be great to see something like a HOL (Hands on Labs) where
> a new experiment is created from the scratch. Parameters should be
> explained in detail, for example: Which impact has the parameter
> Treshold, which impact has WeightRange, etc.? How are the values for
> each parameter determined, what is taken into account when you set
> the values? There are so many unanswered questions for those who are
> new to HyperNEAT and I think most people (including me) have a
> really great interest in this topic, but not the time to read (and
> understand) all the technical papers. So any tutorial should target
> beginners and explain things that have become self-evident for
> intermediates.
>
> I think one such "official" tutorial that explains every step in
> detail should be enough, more will surely follow from the growing
> community.
>
> Cheers,
> Daniel
>
> --- In neat@yahoogroups.com, "Ken" <kstanley@...> wrote:
> >
> >
> >
> > Andrei, which version of HyperNEAT are you interested in and what
> references have you looked at so far? We can potentially improve the
> documentation based on your comments (and a tutorial is a good
> idea), but first I want to understand which "comment-less examples"
> you are referring to.
> >
> > Note that several experiments with complete source code are
> available in two existing HyperNEAT releases of which I am aware.
> These and a variety of publications from several groups are linked
> from the HyperNEAT Users Page, which also provides a brief
> introduction:
> >
> > http://eplex.cs.ucf.edu/hyperNEATpage/HyperNEAT.html
> >
> > I understand you may have already been through this site and its
> associated software and papers, but I wanted to point it out in case
> you had not been aware of it.
> >
> > We want to make the algorithm as accessible as possible so your
> comments are appreciated.
> >
> > ken
> >
> > --- In neat@yahoogroups.com, "Andrei" <andrei.rusu@> wrote:
> > >
> > > Can anyone please recommend some HyperNEAT documentation, a
> tutorial, diagram, some clue, or anything that does not mean reverse
> engineering the comment-less examples ?
> > >
> > > Thanks! Andrei.
> > >
> >
>
>
>

Hello Ken,

here's just another vote for a tutorial, with the difference that I would prefer
it for HyperSharpNEAT.

It would be great to see something like a HOL (Hands on Labs) where a new
experiment is created from the scratch. Parameters should be explained in
detail, for example: Which impact has the parameter Treshold, which impact has
WeightRange, etc.? How are the values for each parameter determined, what is
taken into account when you set the values? There are so many unanswered
questions for those who are new to HyperNEAT and I think most people (including
me) have a really great interest in this topic, but not the time to read (and
understand) all the technical papers. So any tutorial should target beginners
and explain things that have become self-evident for intermediates.

I think one such "official" tutorial that explains every step in detail should
be enough, more will surely follow from the growing community.

Cheers,
Daniel


--- In neat@yahoogroups.com, "Ken" <kstanley@...> wrote:
>
>
>
> Andrei, which version of HyperNEAT are you interested in and what references
have you looked at so far?  We can potentially improve the documentation based
on your comments (and a tutorial is a good idea), but first I want to understand
which "comment-less examples" you are referring to.
>
> Note that several experiments with complete source code are available in two
existing HyperNEAT releases of which I am aware.  These and a variety of
publications from several groups are linked from the HyperNEAT Users Page, which
also provides a brief introduction:
>
> http://eplex.cs.ucf.edu/hyperNEATpage/HyperNEAT.html
>
> I understand you may have already been through this site and its associated
software and papers, but I wanted to point it out in case you had not been aware
of it.
>
> We want to make the algorithm as accessible as possible so your comments are
appreciated.
>
> ken
>
> --- In neat@yahoogroups.com, "Andrei" <andrei.rusu@> wrote:
> >
> > Can anyone please recommend some HyperNEAT documentation, a tutorial,
diagram, some clue, or anything that does not mean reverse engineering the
comment-less examples ?
> >
> > Thanks! Andrei.
> >
>

Jeff, makes sense, thanks for the clarification.  By the way, I think there is a
little confusion with people's names:  There are two different "Kens" who have
been talking to you.  So actually it was Ken Lloyd who made the point about
parallelism.  I'm Ken Stanley, and I didn't actually make that point, although
it makes sense.

ken

--- In neat@yahoogroups.com, Jeff Haynes <feedyurhed@...> wrote:
>
> Ah, no, sorry, just meant that I thought NEAT was the best approach to
> neuroevolution to date.  I don't have any good reason to suspect that F# is
> particularly well suited to it.  I think I agree with you that the parallel
> extensions are the best approach.  There was talk at PDC about the use of
> agents in F# to accomplish parallelism across different boxes.  But there's
> no support for that yet and I don't see any reason that the same concepts
> wouldn't be applied to C# or the other languages when/if they show up.  Of
> course, it's probably just all the marketing hype that I've been exposed to
> talking, but MS was pushing Azure (their cloud solution) very hard this
> year.  It's tempting to imagine writing a version of NEAT that could run on
> Azure.  Has the potential for exposing vast computing resources for
> relatively little coin.  Of course, at this point, if you were going to
> develop something for Azure (or something similar), there are better
> languages than F# (probably C# for Azure and java for just about anything
> else - amazon EC2, hadoop, etc).
>
> - Jeff
>
>
> On Sun, Nov 22, 2009 at 5:19 PM, Ken <kstanley@...> wrote:
>
> >
> >
> >
> >
> > Jeff, I'm not familiar enough with F# to judge whether it is well-suited
> > for NEAT or not. However, I was curious what you meant when you said,
> > "Always thought NEAT was our best chance for success." Is there something
> > you wanted to accomplish with NEAT that you feel F# would make more
> > realistic to accomplish?
> >
> > ken
> >
> >
> > --- In neat@yahoogroups.com <neat%40yahoogroups.com>, Jeff Haynes
> > <feedyurhed@> wrote:
> > >
> > > Hey Ken, thanks for the note. Yeah, I agree that the parallel extensions
> > > are a good alternative. I am definitely not more comfortable in
> > declarative
> > > languages (I'm impressed by anyone who is). I was sitting in a session on
> > > F# at PDC at the time so I guess I was amped up on F# :). We're still
> > > trying to figure out the performance trade-offs between the different
> > > languages (taken in combination with the kernel and architecture changes
> > > we've seen, it's not clear). There was a time when I would have said (did
> > > say) that C++ was the only language for NEAT. However, the advances are
> > > impressive. At any rate, hope you can get back to this at some point!
> > > Always thought NEAT was our best chance for success.
> > >
> > > Cheers,
> > >
> > > Jeff
> > >
> > >
> > > On Thu, Nov 19, 2009 at 3:29 PM, Ken Lloyd <kalloyd@> wrote:
> > >
> > > >
> > > >
> > > > Hi Jeff,
> > > >
> > > > F# tends to be declarative, which is fine if that paradigm is more
> > > > comfortable for you. There are .NET Extensions for Parallel Processing
> > if
> > > > you wish to stay with .NET and object-oriented approaches, say for
> > > > SharpNEAT. Intel has its Parallel Studio, and gives good insight into
> > C++
> > > > HyperNEAT.
> > > >
> > > > The whole issue of partitioning of tasks and data for parallel
> > processing
> > > > is interesting when applied to NEAT - or any genetic-inspired
> > computation.
> > > > I've been experimenting on various fabrics for massively parallel
> > > > computation (on GPUs, for example) for HyperNEAT. So far, I've had some
> > > > successes, but sometimes absolute failures, too.
> > > >
> > > > I've been pulled off my neuroevolution projects for more mundane (read:
> > > > money making) tasks. Hopefully, I can get back to them very shortly.
> > > >
> > > > Ken Lloyd
> > > > Watt Systems Technologies Inc.
> > > >
> > > > ------------------------------
> > > > *From:* neat@yahoogroups.com <neat%40yahoogroups.com> [mailto:
> > neat@yahoogroups.com <neat%40yahoogroups.com>] *On Behalf Of *Jeff
> > > > Haynes
> > > > *Sent:* Thursday, November 19, 2009 12:56 PM
> > > > *To:* neat@yahoogroups.com <neat%40yahoogroups.com>
> > > > *Subject:* [neat] F# NEAT
> > > >
> > > >
> > > >
> > > > Hi, I've been quiet on this group for a long time although I've kept my
> > > > subscription so I remember to play with NEAT once I have free time
> > > > (presumably retirement). I've been tossing around the idea in my head
> > for
> > > > some time of doing an implementation of NEAT in F#. For the
> > uninitiated, F#
> > > > is MS's functional .NET solution to the manycore system. It is
> > completely
> > > > interoperable with C#/VB and can use the .NET framework. I'm still
> > getting
> > > > completely ramped up on it but it seems like it might be very well
> > suited to
> > > > NEAT. I was wondering what people think about this. Waste of time?
> > Maybe
> > > > NEAT would be better suited to hadoop or something like that. Maybe
> > > > something like this has already been done. Anyway, I welcome thoughts.
> > > > Thanks,
> > > >
> > > > Jeff
> > > >
> > > > --
> > > > ...imagine a puddle waking up one morning and thinking, 'This is an
> > > > interesting world I find myself in, an interesting hole I find myself
> > in,
> > > > fits me rather neatly, doesn't it? In fact it fits me staggeringly
> > well,
> > > > must have been made to have me in it!' This is such a powerful idea
> > that as
> > > > the sun rises in the sky and the air heats up and as, gradually, the
> > puddle
> > > > gets smaller and smaller, it's still frantically hanging on to the
> > notion
> > > > that everything's going to be alright, because this world was meant to
> > have
> > > > him in it, was built to have him in it; so the moment he disappears
> > catches
> > > > him rather by surprise. I think this may be something we need to be on
> > the
> > > > watch out for.
> > > >
> > > > -- Douglas Adams
> > > >
> > > >
> > > >
> > >
> > >
> > >
> > > --
> > > ...imagine a puddle waking up one morning and thinking, 'This is an
> > > interesting world I find myself in, an interesting hole I find myself in,
> > > fits me rather neatly, doesn't it? In fact it fits me staggeringly well,
> > > must have been made to have me in it!' This is such a powerful idea that
> > as
> > > the sun rises in the sky and the air heats up and as, gradually, the
> > puddle
> > > gets smaller and smaller, it's still frantically hanging on to the notion
> > > that everything's going to be alright, because this world was meant to
> > have
> > > him in it, was built to have him in it; so the moment he disappears
> > catches
> > > him rather by surprise. I think this may be something we need to be on
> > the
> > > watch out for.
> > >
> > > -- Douglas Adams
> > >
> >
> >
> >
>
>
>
> --
> ...imagine a puddle waking up one morning and thinking, 'This is an
> interesting world I find myself in, an interesting hole I find myself in,
> fits me rather neatly, doesn't it? In fact it fits me staggeringly well,
> must have been made to have me in it!' This is such a powerful idea that as
> the sun rises in the sky and the air heats up and as, gradually, the puddle
> gets smaller and smaller, it's still frantically hanging on to the notion
> that everything's going to be alright, because this world was meant to have
> him in it, was built to have him in it; so the moment he disappears catches
> him rather by surprise. I think this may be something we need to be on the
> watch out for.
>
> -- Douglas Adams
>

Mark, have you tried running a simpler experiment in which you simply train an
agent to collect food scattered over a 2-D world?  That might be a good sanity
check to make sure there is nothing else wrong in the overall system.  It could
expose a bug that might not be obvious in a more complex scenario.

ken

--- In neat@yahoogroups.com, Mark Ahlstrom <lists@...> wrote:
>
> It is normalized.  In full, I'm testing to find the nearest object, then using
(200-d)/200.  Since d will range from very small numbers to 200, that gives me a
good normalized range.
>
> Mark
>
> On Nov 16, 2009, at 3:52 PM, Ken wrote:
>
> >
> >
> > Mark, there is one detail in your setup that sounds potentially very
problematic, although it is possible I am misunderstanding.  You say that the
sensor is set to "200-d."  Is that literally the value that is input, or is it
normalized to a number between 0 and 1?  Note that for a neural network with
regular sigmoid functions, an input with a magnitude over 2 or so will simply
lead to saturation, making it hard for the network to make any useful
distinctions.  Therefore, normalization is very important before inputting
sensor values.
> >
> > ken
> >
> > --- In neat@yahoogroups.com, Mark Ahlstrom <lists@> wrote:
> >>
> >> The food foraging experiment is the dangerous food foraging example
> >> from "Evolving Adaptive Neural Networks with and without Adaptive
> >> Synapses".    The sensors have been tried a few different ways.  They
> >> are arranged around the robot as described in the paper.  If there is
> >> no food item in the arc of the sensor, it is input to the network as
> >> 0.  Otherwise, since I have a 100x100 grid constraining the space of
> >> the objects, the sensor is set to 200-d where d is the distance to the
> >> nearest food item in that sensor arc. Other was that sensors was
> >> implemented was as a count of the number of food items that the sensor
> >> could detect. The outputs are rate of left turn, rate of right turn (I
> >> just take the difference to determine which way to turn) and the
> >> forward speed of the robot.
> >>
> >> This is related to a larger experiment I have been running over the
> >> last couple years (at 1.5 months time per run, it took a while,
> >> particularly to debug a late run memory corruption).  That involved
> >> trying to fly airplanes along a random course.  My hunch there was
> >> that the complexity of the environment and controlled entity left a
> >> relatively naive (in the sense that it just took position and attitude
> >> as input, and generated control settings as output) neat approach
> >> unable to discover a suitably complex control function.  Now Im not as
> >> sure.
> >>
> >> To Anthony's questions: 8 environments are generated for each
> >> generation, and each network is tested on all 8 environments.
> >> Multithreading isn't an issue, since Im keeping it single threaded for
> >> the moment.
> >>
> >> Mark Ahlstrom
> >> On Nov 10, 2009, at 5:42 PM, Ken wrote:
> >>
> >>>
> >>>
> >>> Mark, which food foraging experiment are you implementing?  That is,
> >>> from which paper?  What are the sensors and outputs for your neural
> >>> networks?   I may be able to help more knowing these answers.
> >>>
> >>> Thanks,
> >>>
> >>> ken
> >>>
> >>> --- In neat@yahoogroups.com, "linteil" <lists@> wrote:
> >>>>
> >>>> I've been trying on and off the last couple months to get a couple
> >>>> control experiments running, and have been getting results that
> >>>> appear to have almost a random fitness distribution.  My  control
> >>>> experiment (i.e. the one I think should definitely give a solution)
> >>>> is a re-implementation of the food foraging problem.  The fitness
> >>>> function is the same.  So doing nothing nets a fitness of 32, and
> >>>> max fitness is 60.  Instead what Im seeing is a small improvement
> >>>> to average best fitness of about 35, and then almost every
> >>>> generation I have a couple outliers with a fitness around 40-45.
> >>>>
> >>>> This is all using rtNeat.
> >>>>
> >>>> So, my question is whether or not I likely have some parameters
> >>>> tuned badly (not unlikely) and if so, what the likely culprits
> >>>> would be.  I've tweaked those several times to no avail.  Or,  is
> >>>> it likely just my implementation of the food foraging world?
> >>>>
> >>>> Mark Ahlstrom
> >>>>
> >>>
> >>>
> >>>
> >>>
> >>> ------------------------------------
> >>>
> >>> Yahoo! Groups Links
> >>>
> >>>
> >>>
> >>
> >
> >
> >
> >
> > ------------------------------------
> >
> > Yahoo! Groups Links
> >
> >
> >
>

Jeff, I'm not familiar enough with F# to judge whether it is well-suited for
NEAT or not.  However, I was curious what you meant when you said, "Always
thought NEAT was our best chance for success."  Is there something you wanted to
accomplish with NEAT that you feel F# would make more realistic to accomplish?

ken

--- In neat@yahoogroups.com, Jeff Haynes <feedyurhed@...> wrote:
>
> Hey Ken, thanks for the note.  Yeah, I agree that the parallel extensions
> are a good alternative.  I am definitely not more comfortable in declarative
> languages (I'm impressed by anyone who is).  I was sitting in a session on
> F# at PDC at the time so I guess I was amped up on F# :).  We're still
> trying to figure out the performance trade-offs between the different
> languages (taken in combination with the kernel and architecture changes
> we've seen, it's not clear).  There was a time when I would have said (did
> say) that C++ was the only language for NEAT.  However, the advances are
> impressive.  At any rate, hope you can get back to this at some point!
> Always thought NEAT was our best chance for success.
>
> Cheers,
>
> Jeff
>
>
> On Thu, Nov 19, 2009 at 3:29 PM, Ken Lloyd <kalloyd@...> wrote:
>
> >
> >
> > Hi Jeff,
> >
> > F#  tends to be declarative, which is fine if that paradigm is more
> > comfortable for you.  There are .NET Extensions for Parallel Processing if
> > you wish to stay with .NET and object-oriented approaches, say for
> > SharpNEAT.  Intel has its Parallel Studio, and gives good insight into C++
> > HyperNEAT.
> >
> > The whole issue of partitioning of tasks and data for parallel processing
> > is interesting when applied to NEAT - or any genetic-inspired computation.
> > I've been experimenting on various fabrics for massively parallel
> > computation (on GPUs, for example) for HyperNEAT. So far, I've had some
> > successes, but sometimes absolute failures, too.
> >
> > I've been pulled off my neuroevolution projects for more mundane (read:
> > money making) tasks.  Hopefully, I can get back to them very shortly.
> >
> > Ken Lloyd
> > Watt Systems Technologies Inc.
> >
> >  ------------------------------
> > *From:* neat@yahoogroups.com [mailto:neat@yahoogroups.com] *On Behalf Of
*Jeff
> > Haynes
> > *Sent:* Thursday, November 19, 2009 12:56 PM
> > *To:* neat@yahoogroups.com
> > *Subject:* [neat] F# NEAT
> >
> >
> >
> > Hi, I've been quiet on this group for a long time although I've kept my
> > subscription so I remember to play with NEAT once I have free time
> > (presumably retirement).  I've been tossing around the idea in my head for
> > some time of doing an implementation of NEAT in F#.  For the uninitiated, F#
> > is MS's functional .NET solution to the manycore system.  It is completely
> > interoperable with C#/VB and can use the .NET framework.  I'm still getting
> > completely ramped up on it but it seems like it might be very well suited to
> > NEAT.  I was wondering what people think about this.  Waste of time?  Maybe
> > NEAT would be better suited to hadoop or something like that.  Maybe
> > something like this has already been done.  Anyway, I welcome thoughts.
> > Thanks,
> >
> > Jeff
> >
> > --
> > ...imagine a puddle waking up one morning and thinking, 'This is an
> > interesting world I find myself in, an interesting hole I find myself in,
> > fits me rather neatly, doesn't it? In fact it fits me staggeringly well,
> > must have been made to have me in it!' This is such a powerful idea that as
> > the sun rises in the sky and the air heats up and as, gradually, the puddle
> > gets smaller and smaller, it's still frantically hanging on to the notion
> > that everything's going to be alright, because this world was meant to have
> > him in it, was built to have him in it; so the moment he disappears catches
> > him rather by surprise. I think this may be something we need to be on the
> > watch out for.
> >
> > -- Douglas Adams
> >
> >
> >
>
>
>
> --
> ...imagine a puddle waking up one morning and thinking, 'This is an
> interesting world I find myself in, an interesting hole I find myself in,
> fits me rather neatly, doesn't it? In fact it fits me staggeringly well,
> must have been made to have me in it!' This is such a powerful idea that as
> the sun rises in the sky and the air heats up and as, gradually, the puddle
> gets smaller and smaller, it's still frantically hanging on to the notion
> that everything's going to be alright, because this world was meant to have
> him in it, was built to have him in it; so the moment he disappears catches
> him rather by surprise. I think this may be something we need to be on the
> watch out for.
>
> -- Douglas Adams
>

Different versions of NEAT will vary in precisely how they allocate offspring to
species.  However, ideally the number of children assigned to each species
should be determined before the children are actually created.  Thus there
should never be a need to delete any "excess" genomes, because they will not be
created until the numbers are worked out to sum to the proper total.

ken

--- In neat@yahoogroups.com, "rvonwahlde" <rvonwahlde@...> wrote:
>
> How do you work around the problem when the total number of children each
species spawns is greater than the desired population size?
>
> Buckland's NEAT for Windows code is meant to stop spawning members when the
population size is reached.  I think this prevents the last species in the list
from spawing.
>
> The code at http://neat-python.googlecode.com removes the last added members.
>
> In either case, as the python code notes, "This is dangerous! I can't remove a
species' representant!" i.e. a species exemplar with which newly spawned genomes
will be compared.
>
> I have considered killing off any species that is not allowed to spawn all its
offspring.  I already do so if the spawns required from a given species rounds
to zero.
>
> Or should I just remove any overflow genomes first making sure it is not a
species exemplar?
>

Sorry for the off-topic message: A user from this group "dkuppitz" emailed me,
but the my response was blocked with the following reason:

This account has been disabled or discontinued [#102].

I am posting this message for this user's benefit.

ken

How do you work around the problem when the total number of children each
species spawns is greater than the desired population size?

Buckland's NEAT for Windows code is meant to stop spawning members when the
population size is reached.  I think this prevents the last species in the list
from spawing.

The code at http://neat-python.googlecode.com removes the last added members.

In either case, as the python code notes, "This is dangerous! I can't remove a
species' representant!" i.e. a species exemplar with which newly spawned genomes
will be compared.

I have considered killing off any species that is not allowed to spawn all its
offspring.  I already do so if the spawns required from a given species rounds
to zero.

Or should I just remove any overflow genomes first making sure it is not a
species exemplar?

---

From: neat@yahoogroups.com [mailto:neat@yahoogroups.com] On Behalf Of Jeff Haynes
Sent: Thursday, November 19, 2009 12:56 PM
To: neat@yahoogroups.com
Subject: [neat] F# NEAT

 

Hi, I've been quiet on this group for a long time although I've kept my subscription so I remember to play with NEAT once I have free time (presumably retirement).  I've been tossing around the idea in my head for some time of doing an implementation of NEAT in F#.  For the uninitiated, F# is MS's functional .NET solution to the manycore system.  It is completely interoperable with C#/VB and can use the .NET framework.  I'm still getting completely ramped up on it but it seems like it might be very well suited to NEAT.  I was wondering what people think about this.  Waste of time?  Maybe NEAT would be better suited to hadoop or something like that.  Maybe something like this has already been done.  Anyway, I welcome thoughts.  Thanks,

Jeff

--
...imagine a puddle waking up one morning and thinking, 'This is an interesting world I find myself in, an interesting hole I find myself in, fits me rather neatly, doesn't it? In fact it fits me staggeringly well, must have been made to have me in it!' This is such a powerful idea that as the sun rises in the sky and the air heats up and as, gradually, the puddle gets smaller and smaller, it's still frantically hanging on to the notion that everything's going to be alright, because this world was meant to have him in it, was built to have him in it; so the moment he disappears catches him rather by surprise. I think this may be something we need to be on the watch out for.

-- Douglas Adams

It is normalized.  In full, I'm testing to find the nearest object, then using
(200-d)/200.  Since d will range from very small numbers to 200, that gives me a
good normalized range.

Mark

On Nov 16, 2009, at 3:52 PM, Ken wrote:

>
>
> Mark, there is one detail in your setup that sounds potentially very
problematic, although it is possible I am misunderstanding.  You say that the
sensor is set to "200-d."  Is that literally the value that is input, or is it
normalized to a number between 0 and 1?  Note that for a neural network with
regular sigmoid functions, an input with a magnitude over 2 or so will simply
lead to saturation, making it hard for the network to make any useful
distinctions.  Therefore, normalization is very important before inputting
sensor values.
>
> ken
>
> --- In neat@yahoogroups.com, Mark Ahlstrom <lists@...> wrote:
>>
>> The food foraging experiment is the dangerous food foraging example
>> from "Evolving Adaptive Neural Networks with and without Adaptive
>> Synapses".    The sensors have been tried a few different ways.  They
>> are arranged around the robot as described in the paper.  If there is
>> no food item in the arc of the sensor, it is input to the network as
>> 0.  Otherwise, since I have a 100x100 grid constraining the space of
>> the objects, the sensor is set to 200-d where d is the distance to the
>> nearest food item in that sensor arc. Other was that sensors was
>> implemented was as a count of the number of food items that the sensor
>> could detect. The outputs are rate of left turn, rate of right turn (I
>> just take the difference to determine which way to turn) and the
>> forward speed of the robot.
>>
>> This is related to a larger experiment I have been running over the
>> last couple years (at 1.5 months time per run, it took a while,
>> particularly to debug a late run memory corruption).  That involved
>> trying to fly airplanes along a random course.  My hunch there was
>> that the complexity of the environment and controlled entity left a
>> relatively naive (in the sense that it just took position and attitude
>> as input, and generated control settings as output) neat approach
>> unable to discover a suitably complex control function.  Now Im not as
>> sure.
>>
>> To Anthony's questions: 8 environments are generated for each
>> generation, and each network is tested on all 8 environments.
>> Multithreading isn't an issue, since Im keeping it single threaded for
>> the moment.
>>
>> Mark Ahlstrom
>> On Nov 10, 2009, at 5:42 PM, Ken wrote:
>>
>>>
>>>
>>> Mark, which food foraging experiment are you implementing?  That is,
>>> from which paper?  What are the sensors and outputs for your neural
>>> networks?   I may be able to help more knowing these answers.
>>>
>>> Thanks,
>>>
>>> ken
>>>
>>> --- In neat@yahoogroups.com, "linteil" <lists@> wrote:
>>>>
>>>> I've been trying on and off the last couple months to get a couple
>>>> control experiments running, and have been getting results that
>>>> appear to have almost a random fitness distribution.  My  control
>>>> experiment (i.e. the one I think should definitely give a solution)
>>>> is a re-implementation of the food foraging problem.  The fitness
>>>> function is the same.  So doing nothing nets a fitness of 32, and
>>>> max fitness is 60.  Instead what Im seeing is a small improvement
>>>> to average best fitness of about 35, and then almost every
>>>> generation I have a couple outliers with a fitness around 40-45.
>>>>
>>>> This is all using rtNeat.
>>>>
>>>> So, my question is whether or not I likely have some parameters
>>>> tuned badly (not unlikely) and if so, what the likely culprits
>>>> would be.  I've tweaked those several times to no avail.  Or,  is
>>>> it likely just my implementation of the food foraging world?
>>>>
>>>> Mark Ahlstrom
>>>>
>>>
>>>
>>>
>>>
>>> ------------------------------------
>>>
>>> Yahoo! Groups Links
>>>
>>>
>>>
>>
>
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>

Mark, there is one detail in your setup that sounds potentially very
problematic, although it is possible I am misunderstanding.  You say that the
sensor is set to "200-d."  Is that literally the value that is input, or is it
normalized to a number between 0 and 1?  Note that for a neural network with
regular sigmoid functions, an input with a magnitude over 2 or so will simply
lead to saturation, making it hard for the network to make any useful
distinctions.  Therefore, normalization is very important before inputting
sensor values.

ken

--- In neat@yahoogroups.com, Mark Ahlstrom <lists@...> wrote:
>
> The food foraging experiment is the dangerous food foraging example
> from "Evolving Adaptive Neural Networks with and without Adaptive
> Synapses".    The sensors have been tried a few different ways.  They
> are arranged around the robot as described in the paper.  If there is
> no food item in the arc of the sensor, it is input to the network as
> 0.  Otherwise, since I have a 100x100 grid constraining the space of
> the objects, the sensor is set to 200-d where d is the distance to the
> nearest food item in that sensor arc. Other was that sensors was
> implemented was as a count of the number of food items that the sensor
> could detect. The outputs are rate of left turn, rate of right turn (I
> just take the difference to determine which way to turn) and the
> forward speed of the robot.
>
> This is related to a larger experiment I have been running over the
> last couple years (at 1.5 months time per run, it took a while,
> particularly to debug a late run memory corruption).  That involved
> trying to fly airplanes along a random course.  My hunch there was
> that the complexity of the environment and controlled entity left a
> relatively naive (in the sense that it just took position and attitude
> as input, and generated control settings as output) neat approach
> unable to discover a suitably complex control function.  Now Im not as
> sure.
>
> To Anthony's questions: 8 environments are generated for each
> generation, and each network is tested on all 8 environments.
> Multithreading isn't an issue, since Im keeping it single threaded for
> the moment.
>
> Mark Ahlstrom
> On Nov 10, 2009, at 5:42 PM, Ken wrote:
>
> >
> >
> > Mark, which food foraging experiment are you implementing?  That is,
> > from which paper?  What are the sensors and outputs for your neural
> > networks?   I may be able to help more knowing these answers.
> >
> > Thanks,
> >
> > ken
> >
> > --- In neat@yahoogroups.com, "linteil" <lists@> wrote:
> >>
> >> I've been trying on and off the last couple months to get a couple
> >> control experiments running, and have been getting results that
> >> appear to have almost a random fitness distribution.  My  control
> >> experiment (i.e. the one I think should definitely give a solution)
> >> is a re-implementation of the food foraging problem.  The fitness
> >> function is the same.  So doing nothing nets a fitness of 32, and
> >> max fitness is 60.  Instead what Im seeing is a small improvement
> >> to average best fitness of about 35, and then almost every
> >> generation I have a couple outliers with a fitness around 40-45.
> >>
> >> This is all using rtNeat.
> >>
> >> So, my question is whether or not I likely have some parameters
> >> tuned badly (not unlikely) and if so, what the likely culprits
> >> would be.  I've tweaked those several times to no avail.  Or,  is
> >> it likely just my implementation of the food foraging world?
> >>
> >> Mark Ahlstrom
> >>
> >
> >
> >
> >
> > ------------------------------------
> >
> > Yahoo! Groups Links
> >
> >
> >
>

The food foraging experiment is the dangerous food foraging example
from "Evolving Adaptive Neural Networks with and without Adaptive
Synapses".    The sensors have been tried a few different ways.  They
are arranged around the robot as described in the paper.  If there is
no food item in the arc of the sensor, it is input to the network as
0.  Otherwise, since I have a 100x100 grid constraining the space of
the objects, the sensor is set to 200-d where d is the distance to the
nearest food item in that sensor arc. Other was that sensors was
implemented was as a count of the number of food items that the sensor
could detect. The outputs are rate of left turn, rate of right turn (I
just take the difference to determine which way to turn) and the
forward speed of the robot.

This is related to a larger experiment I have been running over the
last couple years (at 1.5 months time per run, it took a while,
particularly to debug a late run memory corruption).  That involved
trying to fly airplanes along a random course.  My hunch there was
that the complexity of the environment and controlled entity left a
relatively naive (in the sense that it just took position and attitude
as input, and generated control settings as output) neat approach
unable to discover a suitably complex control function.  Now Im not as
sure.

To Anthony's questions: 8 environments are generated for each
generation, and each network is tested on all 8 environments.
Multithreading isn't an issue, since Im keeping it single threaded for
the moment.

Mark Ahlstrom
On Nov 10, 2009, at 5:42 PM, Ken wrote:

>
>
> Mark, which food foraging experiment are you implementing?  That is,
> from which paper?  What are the sensors and outputs for your neural
> networks?   I may be able to help more knowing these answers.
>
> Thanks,
>
> ken
>
> --- In neat@yahoogroups.com, "linteil" <lists@...> wrote:
>>
>> I've been trying on and off the last couple months to get a couple
>> control experiments running, and have been getting results that
>> appear to have almost a random fitness distribution.  My  control
>> experiment (i.e. the one I think should definitely give a solution)
>> is a re-implementation of the food foraging problem.  The fitness
>> function is the same.  So doing nothing nets a fitness of 32, and
>> max fitness is 60.  Instead what Im seeing is a small improvement
>> to average best fitness of about 35, and then almost every
>> generation I have a couple outliers with a fitness around 40-45.
>>
>> This is all using rtNeat.
>>
>> So, my question is whether or not I likely have some parameters
>> tuned badly (not unlikely) and if so, what the likely culprits
>> would be.  I've tweaked those several times to no avail.  Or,  is
>> it likely just my implementation of the food foraging world?
>>
>> Mark Ahlstrom
>>
>
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>

Mark, which food foraging experiment are you implementing?  That is, from which
paper?  What are the sensors and outputs for your neural networks?   I may be
able to help more knowing these answers.

Thanks,

ken

--- In neat@yahoogroups.com, "linteil" <lists@...> wrote:
>
> I've been trying on and off the last couple months to get a couple control
experiments running, and have been getting results that appear to have almost a
random fitness distribution.  My  control experiment (i.e. the one I think
should definitely give a solution) is a re-implementation of the food foraging
problem.  The fitness function is the same.  So doing nothing nets a fitness of
32, and max fitness is 60.  Instead what Im seeing is a small improvement to
average best fitness of about 35, and then almost every generation I have a
couple outliers with a fitness around 40-45.
>
> This is all using rtNeat.
>
> So, my question is whether or not I likely have some parameters tuned badly
(not unlikely) and if so, what the likely culprits would be.  I've tweaked those
several times to no avail.  Or,  is it likely just my implementation of the food
foraging world?
>
> Mark Ahlstrom
>

I've been trying on and off the last couple months to get a couple control
experiments running, and have been getting results that appear to have almost a
random fitness distribution.  My  control experiment (i.e. the one I think
should definitely give a solution) is a re-implementation of the food foraging
problem.  The fitness function is the same.  So doing nothing nets a fitness of
32, and max fitness is 60.  Instead what Im seeing is a small improvement to
average best fitness of about 35, and then almost every generation I have a
couple outliers with a fitness around 40-45.

This is all using rtNeat.

So, my question is whether or not I likely have some parameters tuned badly (not
unlikely) and if so, what the likely culprits would be.  I've tweaked those
several times to no avail.  Or,  is it likely just my implementation of the food
foraging world?

Mark Ahlstrom

Hey Andrei,

It's true that the HyperNEAT experiments are poorly documented and can be
confusing.  This is largely because the HyperNEAT algorithm itself has evolved
with each of the experiments and, as a result, there is a lot of duplicate code
and the HyperNEAT algorithm is not general.  In the past few months I've managed
to pull the HyperNEAT algorithm out of the experiments and into the NEAT
library.  I've also made a host of changes to add structure to the code.  These
changes will be in the next version that I hope to release within the next few
weeks.

What I haven't done is made an attempt to document.  I will try to add
documentation in the code as well as a small writeup in the README file
explaining what the different files in the library do.

--- In neat@yahoogroups.com, Andrei Rusu <andrei.rusu@...> wrote:
>
> I should have specified that I was talking exclusively  about the HyperNEAT
2.6 C++ implementation. I read some of the publications and the ideas are
conceptually clear, also read the website, but the implementation is very
confusing to me. Maybe it's because I am new to evolving CPPNs and also to NEAT.
Anyway, I tried to get some insight out of the code in
"HyperNEAT/Hypercube_NEAT/src/Experiments", but I find it hard to get a clear
picture of how the library is supposed to be used correctly.
>
> Maybe this is because I am not an experienced NEAT user. Shoud I start with
that?
>
>
> Many thanks?
>     Andrei.
>
>
>
>
>
> ________________________________
> From: Ken <kstanley@...>
> To: neat@yahoogroups.com
> Sent: Sat, November 7, 2009 3:47:29 PM
> Subject: [neat] Re: HyperNEAT Tutorial?
>
>
>
>
> Andrei, which version of HyperNEAT are you interested in and what references
have you looked at so far?  We can potentially improve the documentation based
on your comments (and a tutorial is a good idea), but first I want to understand
which "comment-less examples" you are referring to.
>
> Note that several experiments with complete source code are available in two
existing HyperNEAT releases of which I am aware.  These and a variety of
publications from several groups are linked from the HyperNEAT Users Page, which
also provides a brief introduction:
>
> http://eplex. cs.ucf.edu/ hyperNEATpage/ HyperNEAT. html
>
> I understand you may have already been through this site and its associated
software and papers, but I wanted to point it out in case you had not been aware
of it.
>
> We want to make the algorithm as accessible as possible so your comments are
appreciated.
>
> ken
>
> --- In neat@yahoogroups. com, "Andrei" <andrei.rusu@ ...> wrote:
> >
> > Can anyone please recommend some HyperNEAT documentation, a tutorial,
diagram, some clue, or anything that does not mean reverse engineering the
comment-less examples ?
> >
> > Thanks! Andrei.
> >
>

Yes I would advise starting out with NEAT to get familiar with it.  However, we
can also look into improving the understandability of the HyperNEAT C++ release.
Thanks for bringing it to our attention.

ken.

--- In neat@yahoogroups.com, Andrei Rusu <andrei.rusu@...> wrote:
>
> I should have specified that I was talking exclusively  about the HyperNEAT
2.6 C++ implementation. I read some of the publications and the ideas are
conceptually clear, also read the website, but the implementation is very
confusing to me. Maybe it's because I am new to evolving CPPNs and also to NEAT.
Anyway, I tried to get some insight out of the code in
"HyperNEAT/Hypercube_NEAT/src/Experiments", but I find it hard to get a clear
picture of how the library is supposed to be used correctly.
>
> Maybe this is because I am not an experienced NEAT user. Shoud I start with
that?
>
>
> Many thanks?
>     Andrei.
>
>
>
>
>
> ________________________________
> From: Ken <kstanley@...>
> To: neat@yahoogroups.com
> Sent: Sat, November 7, 2009 3:47:29 PM
> Subject: [neat] Re: HyperNEAT Tutorial?
>
>
>
>
> Andrei, which version of HyperNEAT are you interested in and what references
have you looked at so far?  We can potentially improve the documentation based
on your comments (and a tutorial is a good idea), but first I want to understand
which "comment-less examples" you are referring to.
>
> Note that several experiments with complete source code are available in two
existing HyperNEAT releases of which I am aware.  These and a variety of
publications from several groups are linked from the HyperNEAT Users Page, which
also provides a brief introduction:
>
> http://eplex. cs.ucf.edu/ hyperNEATpage/ HyperNEAT. html
>
> I understand you may have already been through this site and its associated
software and papers, but I wanted to point it out in case you had not been aware
of it.
>
> We want to make the algorithm as accessible as possible so your comments are
appreciated.
>
> ken
>
> --- In neat@yahoogroups. com, "Andrei" <andrei.rusu@ ...> wrote:
> >
> > Can anyone please recommend some HyperNEAT documentation, a tutorial,
diagram, some clue, or anything that does not mean reverse engineering the
comment-less examples ?
> >
> > Thanks! Andrei.
> >
>

Buckland's NEAT for windows code uses the Adjusted Fitness to calculate Span
Amount.  Is this incorrect?

In CSpecies::AdjustFitnesses(), for each member of a species, the fitness is
boosted or punished due to age then divided by the number of members in that
species: AdjustedFitness.

This is used to

//calculate new adjusted total & average fitness for the population
   for (gen=0; gen<m_vecGenomes.size(); ++gen)
   {
      m_dTotFitAdj += m_vecGenomes[gen].GetAdjFitness();
   }

   m_dAvFitAdj = m_dTotFitAdj/m_vecGenomes.size();

   //calculate how many offspring each member of the population
   //should spawn
   for (gen=0; gen<m_vecGenomes.size(); ++gen)
   {
      double ToSpawn = m_vecGenomes[gen].GetAdjFitness() / m_dAvFitAdj;

      m_vecGenomes[gen].SetAmountToSpawn(ToSpawn);
   }

The results are the same as using:

Offspring = (AverageSpeciesFitness / Total_of_AverageSpeciesFitnesss)
* PopulationSize

ONLY if the boost or punish factors are the same for each species.

Buckland's NEAT for windows code uses the Adjusted Fitness to calculate Span
Amount.  Is this incorrect?

In CSpecies::AdjustFitnesses(), for each member of a species, the fitness is
boosted or punished due to age then divided by the number of members in that
species: AdjustedFitness.

This is used to

//calculate new adjusted total & average fitness for the population
   for (gen=0; gen<m_vecGenomes.size(); ++gen)
   {
      m_dTotFitAdj += m_vecGenomes[gen].GetAdjFitness();
   }

   m_dAvFitAdj = m_dTotFitAdj/m_vecGenomes.size();

   //calculate how many offspring each member of the population
   //should spawn
   for (gen=0; gen<m_vecGenomes.size(); ++gen)
   {
      double ToSpawn = m_vecGenomes[gen].GetAdjFitness() / m_dAvFitAdj;

      m_vecGenomes[gen].SetAmountToSpawn(ToSpawn);
   }

The results are the same as using:

Offspring = (AverageSpeciesFitness / Total_of_AverageSpeciesFitnesss)
* PopulationSize

ONLY if the boost or punish factors are the same for each species.

---

From: neat@yahoogroups.com [mailto:neat@yahoogroups.com] On Behalf Of Nicolas Bredeche
Sent: Monday, November 09, 2009 1:24 AM
To: neat@yahoogroups.com
Subject: [neat] announcing new mailing list on Evolutionary Design of Robots

 

Dear all,

Following the IROS workshop on Evolutionary Design of Robots held in october 2009, during IROS,
we are starting a new mailing list regarding general considerations and announcements in this field.

If you want to join the list, you just have to send an email to sympa@listes.upmc.fr
with the subject: sub evoderob.

The mailing may be used to post all relevant information regarding evolutionary design of robot(s),
including control and morphology related issues. Paper summary, announcement and call for papers
may also be posted on this list. We will also post a general question from time to time for everyone
to provide his/her own opinion and to share ideas among us.

Please fill free to send this message to anyone who might be interested!

Best regards,

-nicolas, on behalf of the evoderob organizing committee

---
http:://www.isir.fr/evoderob

Andrei, if you want to learn the underlying NEAT method by looking at c++ code,
the best I have seen is Dr. Kenneth Stanley's rtNEAT c++ code. It is fairly well
commented, the class headers have descriptions and the most important functions
are narrated. It has a few simple examples to show you how a basic experiment
can work. The 'rt' is for "real-time" experiments, you can just ignore the rt
code and it behaves like regular NEAT. I think you can download it either from
the archives of this group, or from Dr. Stanley's web page.

I think the HyperNEAT implementation you are speaking of is Jason Gauci's
implementation. It is the only HyperNEAT c++ code that I am aware of. It has
very few comments, and it utilizes more advanced c++ concepts like linking to
external libraries, boost, templates, and inheritance. When I was new to c++ and
to NEAT, hyperNEAT 2.6 was a bit overwhelming. It will make more sense after you
have a better understanding of regular NEAT.

--- In neat@yahoogroups.com, Andrei Rusu <andrei.rusu@...> wrote:
>
> I should have specified that I was talking exclusively  about the HyperNEAT
2.6 C++ implementation. I read some of the publications and the ideas are
conceptually clear, also read the website, but the implementation is very
confusing to me. Maybe it's because I am new to evolving CPPNs and also to NEAT.
Anyway, I tried to get some insight out of the code in
"HyperNEAT/Hypercube_NEAT/src/Experiments", but I find it hard to get a clear
picture of how the library is supposed to be used correctly.
>
> Maybe this is because I am not an experienced NEAT user. Shoud I start with
that?
>
>
> Many thanks?
>     Andrei.
>
>
>
>
>
> ________________________________
> From: Ken <kstanley@...>
> To: neat@yahoogroups.com
> Sent: Sat, November 7, 2009 3:47:29 PM
> Subject: [neat] Re: HyperNEAT Tutorial?
>
>
>
>
> Andrei, which version of HyperNEAT are you interested in and what references
have you looked at so far?  We can potentially improve the documentation based
on your comments (and a tutorial is a good idea), but first I want to understand
which "comment-less examples" you are referring to.
>
> Note that several experiments with complete source code are available in two
existing HyperNEAT releases of which I am aware.  These and a variety of
publications from several groups are linked from the HyperNEAT Users Page, which
also provides a brief introduction:
>
> http://eplex. cs.ucf.edu/ hyperNEATpage/ HyperNEAT. html
>
> I understand you may have already been through this site and its associated
software and papers, but I wanted to point it out in case you had not been aware
of it.
>
> We want to make the algorithm as accessible as possible so your comments are
appreciated.
>
> ken
>
> --- In neat@yahoogroups. com, "Andrei" <andrei.rusu@ ...> wrote:
> >
> > Can anyone please recommend some HyperNEAT documentation, a tutorial,
diagram, some clue, or anything that does not mean reverse engineering the
comment-less examples ?
> >
> > Thanks! Andrei.
> >
>