I set up an Galapagos optimization with 9 sliders.
Is it possible to display a meaningful fitness landscape with so many genes ?
I found no example of how to setup the fitness landscape component, even in a simple case…
I set up an Galapagos optimization with 9 sliders.
Just a try
fit.gh (8.1 KB)
Call me stupid, but I still have no idea what this component does.
What I learned here :
-This component does not require Galapagos to be running
-If you enter a bunch of values, out comes a nice colorful topo map
I have no idea how the data is mapped on the rectangle, and even less what all the variants do (basin, feature, slope,…)
I’m really frustrated by all these components thrown at our faces without the tinyest bit of documentation.
I am like you , i have no idea what this component used for
I think I read something about it on I Eat Bug For Breakfast
But not really sure about what it does and the capacity of the component.
To me both X and Y axis of your rectangle correspond to genes, and the Y axis it the fitness value.
So in this case, this component only works with two genes (2dimension) while the fitness value is the 3rd dimension.
When you take it to you 9 sliders question, it means that the fitness landscape is in 10 dimensions.
I thinks there are ways to reduce dimensions, I’ve seen examples that could take many dimensions and display it, but it’s way above my knowledge
What I think this components does is just expect a squared grid of values in a flat list, ie, a list of N values where the square root of N is an integer, so it can use this integer to define the number of rows and columns whitin the rectangle domain, sample points in a grid on it and use each value as height.
In Khaled’s example, there is no sorting of “X” and “Y” genes, and no notion of fitness there’s just a bunch of values in a flat list.
The component even has a cryptic “Count” input which doesn’t seem to serve any purpose apart from error messages if the count number is not divisible by it.
I think there’s a misunderstanding here. Apart from projecting a multidimensional space to 2 or 3 dimensions, which can be done using Principal Component Analysis or Autoencoders for example, what you have using Galapagos is a value in each dimension, not its full function.
But apart from Galapagos, you have a fitness function that you can sample in 9 dimensional points and get the result. For those coordinates, you reduce their dimensions to 2 or 3, then you use these reduced points with the result.
EDIT: I think your best bet is to use other ways of represent multimensional data. For example, why not set each dimension as a polar array, so that you have 9 axis along 360 degrees, and use the result as an elevation?
Nothing here makes any sense to me.
If you don’t tell the component what you mean by “fitness”, how could it organize the genes in a way that reveals which gene values yield “fitness” ?
You have a fitness function, all in between the genes and their fitness value.
If you use other genes, with the same fitness function, you have another fitness value.
fitness = FitnessFunction(genes)
Then with an optimization solver, you can find the genes that maximize or minimize the fitness, but if you display this function, you can see visually which genes are the best.
Does it help?
I have done many optimizations, and am quite confident that I understand the concept, but I just don’t understand how the “Fitness landscape” component can do what it is supposed to do if it can only be fed a flat list of values.
To make any sense, it should require the input of :
-A tree with the various gene lists
-A tree with, in each branch, the value produced by each gene list
-A target value
A simple and clear example would go a long way, instead of referring to obtuse math papers and collapsing of dimensions…
Here’s my fancy link :
“What you understand well, you enunciate clearly”
You’re assuming something it doesn’t do, which is reduce dimensions. This component is very simple, you need to map your 9-dimensional genes to a 2-dimensional space to work with it.
Dani, you’re just dodging the elephant in the room here.
How is the notion of “fitness” of these genes encoded in the flat list that you input ?
This is driving me nuts !
Can’t anyone come up with a simple example ?
Imagine you have two genes, two dimensional problem. For each one, you need a minimum and a maximum value. Then you create a range of values for each gene dimension. You have a grid of 2d points and you evaluate the fitness function with them. For each point, you have a fitness, that’s the list you have to give the component.
For more dimensions, you need to do what I comment before.
As i understand from this articlrle we can’t use more than 2 values lists.
GeneA , GeneB ( x and y directions); maybe average is a solution? when we have many sliders
OK, so you don’t give the values of the genes, but the value calculated from the genes, value that you seek to optimize.
But the problem is intact : how could the component extrapolate the pairs of gene value that yield the calculated values if this information is not fed in ?
In fact, the fitness function is a surjection : multiple pairs of genes could produce the same calculated value.
This article does a good job at explaining what a fitness function is, but not how the fitness landscape component works.
It is just a height map component. I told you before how it works. It doesn’t do what do you expect. It just have a funcy name.
But why are you assuming that? A fitness landscape is just the function surface of all fitness values, as a height map in 2d, where the axis of that space represents the dimensions of the genes/parameters.
The description of the component is clear (well, maybe no) , “Display a 2.5D fitness landscape”, the 2D are coded such how do you sort (in row and columns) the list of values and the 0.5D the fitness value dimension.
If you feed it with four values, it positions will be the corners of the rectangle. if you feed it with 9 values, their positions will be the corners and the halves.
This is why I don’t understand Khaled’s example : the values are input as a flat list.