Darwinbots Forum
Code center => Suggestions => Topic started by: jknilinux on October 11, 2008, 04:35:59 AM
-
Hi Everyone!
This thread is continued from a thread in the DB3 forum. If you are unfamiliar with the discussion, you can see it [a href=\'index.php?showtopic=2908\']here![/a]
Basically, the problem is that whenever someone tries to run a DB evosim, the bots end up "evolving" until they are filled with random crud and are unable to eat, because necessary genes have been overwritten. Eric first noticed that real-life evolution almost never modifies necessary metabolic pathways, even though these genes make up the bulk of our genome. Instead, less necessary genes, such as those controlling the number of fingers, are mutated much more often. So, something must be protecting those necessary genes from mutation, and the reason that evolution rarely works in DB is probably because it lacks this feature.
So, I'll try to see which algorithm is most popular, and then maybe we should implement that one first.
So far, there are four options: (I'm trying to make it objective, but some of my bias may show through. Let me know if I forgot a pro/con)
Number 1: Make metadata (Mutation-Rate data) instructions that attach to the DNA but are not DNA instructions, like [x10] ... [/x10]
Pros:
The mutation rate data is "glued" to it's assigned exon.
Evolution cannot delete/move a codule
Mutation protection cannot be overwritten if used more than once, since the mutation protection is Metadata.
Cons:
Fragile (it's more than one instruction long, so evolution and new coders could break it more easily)
Evolution cannot delete/move a codule
Number 2: Make a new instruction, such as x .protect25 store, to protect the next x bases by giving them a mutation rate of 25%.
Pros:
Easy for new coders and evolution to use.
Robust, since it can be put anywhere in a genome, or have x changed, etc..., and it will still function.
Easy to add to the next version of DB, since less work is required.
Evolution can delete/move it, since it is DNA.
Cons:
The mutation rate data is not "glued" to it's assigned exon.
Evolution can delete/move it, since it is DNA.
Mutation protection may be overwritten if used more than once, since the mutation protection is not Metadata.
Number 3: Make mutation immunity have a cost. If a bot is unable to pay the cost, immunity is lost. Immunity also degrades over time. Basically it would work like this:
Step 1-make enzyme. This will act the same way as slime does, decaying over time, more enzyme provides more protection eg reduce chance of mutatoins
Step 2-use X .protect store; if X is negative, it will protect X bps before the command, if positive, the next X bps after the command. The bigger the size of code protected, the faster enzymes wear off.
Note that Bacillus later changed Step 2 to tagging with metadata, which allows multiple protects in one cycle (not sure about logic though), and the distribution of substances.
Pros:
Time- and cost-dependent
Easy for new coders and evolution to use.
Robust, since it can be put anywhere in a genome, or have x changed, etc..., and it will still function.
Easy to add to the next version of DB, since less work is required.
Evolution can delete/move it, since it is DNA.
Cons:
Mutation protection may be overwritten if used more than once, since the mutation protection is not Metadata.
The mutation rate data is not "glued" to it's assigned exon.
Evolution can delete/move it, since it is DNA.
Number 4: Make a hybrid algorithm that combines the best features of different ideas. For example, a mutation control instruction that IS glued to it's assigned exon and applies the mutation rate it encodes to itself.
These Pros and Cons will look at an implementation of the MPPI instruction.
Pros:
Easy for new coders and evolution to use.
Robust, since it can be put anywhere in a genome, or have x changed, etc..., and it will still function.
Easy to add to the next version of DB, since less work is required than idea 1, but there's more than 2.
Evolution can delete/move it or not, it's up to the coder. Put x .protect0 store to make itself and the following x lines of code unchangeable.
The mutation rate data is "glued" to it's assigned exon.
Cons:
Mutation protection may be overwritten if used more than once, since the mutation protection is not Metadata.
Number 5: Bacillus' Idea: A hybrid of 1 and 3, where mutation immunity for an exon is governed by metadata attached to the DNA (as a codule), but can be lost if the bot is not able to pay the immunity costs and/or if the bot gets too old.
Pros:
The mutation rate data is "glued" to it's assigned exon.
Evolution cannot delete/move a codule
Mutation protection cannot be overwritten if used more than once, since the mutation protection is Metadata.
Cons:
Fragile (it's more than one instruction long, so evolution and new coders could break it more easily)
Evolution cannot delete/move a codule
Number 6: Ikkes' DNA comparison Idea: Make one or more copies of the genome, and if one copy is mutated, replace the mutated code with the equivalent code from another copy. Checking for mutation is done by comparing the genomes' DNA line-by-line.
EDITED!
Pros:
Allows evolution to make the genes from the two copies interact to create a novel outcome.
The required instructions could be used for other uses by evolution, since they are general-purpose.
Because the instructions are more flexible, a bot could have conditional mutation protection.
Cons:
If damage needs to be repaired, then it may slow down the sim if twice the amount of DNA is executed each cycle, since there will need to be a copy of the bots' genome.
Number 7: Ikkes' Hash comparison Idea: Make one or more copies of the genome, and if one copy is mutated, replace the mutated code with the equivalent code from another copy. Checking for mutation is done by comparing the genomes' Hashes.
EDITED!
Pros:
Allows evolution to make the genes from the two copies interact to create a novel outcome.
The required instructions could be used for other uses by evolution, since they are general-purpose.
Because the instructions are more flexible, a bot could have conditional mutation protection.
Cons:
If damage needs to be repaired, then it may slow down the sim if twice the amount of DNA is executed each cycle, since there will need to be a copy of the bots' genome.
Thanks for voting!
Note: I moved the hybrid option back up because someone voted for it, but after I added the other ideas it was moved down and Bacillus' second idea got the vote.
-
In reply to 3.), it simple represents an effective 'mutation-immunity' system becoming ineffective over time, and needing refreshing. The major issue (note that this is not the only suggestion that has this issue) is that it relies on the data being stored in a memory location; multiple attempts at protecting DNA will override previous attempts, therefore the way to go will eventually be in the form of metadata. Based on that, I'd change my suggestion to combine the metatag suggestion with the protective enzyme protection system, which also gives a way to control the costs of protecting DNA. (in nrg per unit produced, evenly distributed within the tags, or perhaps allocated by a variable)
EDIT=>Don't forget that most people invloved in this discussion put forward an idea themselves, so I'd be surprised if there is a clear winner
-
In reply to 3.), it simple represents an effective 'mutation-immunity' system becoming ineffective over time, and needing refreshing. The major issue (note that this is not the only suggestion that has this issue) is that it relies on the data being stored in a memory location; multiple attempts at protecting DNA will override previous attempts, therefore the way to go will eventually be in the form of metadata. Based on that, I'd change my suggestion to combine the metatag suggestion with the protective enzyme protection system, which also gives a way to control the costs of protecting DNA. (in nrg per unit produced, evenly distributed within the tags, or perhaps allocated by a variable)
EDIT=>Don't forget that most people invloved in this discussion put forward an idea themselves, so I'd be surprised if there is a clear winner
Could you explain how trying to protect the DNA more than once would cause the Mutation protection instructions to be overwritten? Also, how would you combine enzymatic protection with metadata?
EDIT=> There probably won't be overwhelming support for one of the suggestions, but if there is a significant majority then we'd have to go with that. I'll also add ideas to the poll as they come up.
I'll need to leave your original suggestion on the poll, since some people have already voted in favor of it.
NUMSGIL, ERICL & IKKE: Did I summarize your ideas so they reflect your original opinions? Let me know!
-
Actually I gave two different suggestions, both located within the gene and based on some compare function
1) compare different copies of the same gene (not necessarily two)
2) compare an actual hash value of a section of the genome with the stored one (stored in the genome)
Additionally I suggested some repair/ kill function to follow the compare function. This might not be needed though: genes can already be deleted, so one programming option would be to delete the reproductive gene if a mutation has been detected.
A simple form of mutation protection would be something like:
if gene1 !=gene2 delgene reproduce
or
if hash (gene1)!=1234 delgene reproduce
combined:
if hash(gene1) != hash(gene2).....
BTW: some bots already have a level of mutation protection by means of attacking mutants.
The main things I want to get out of this are the following:
1) mutation protection is located within the genome
2) mutation protection is done by combining generic instructions which also have other possible applications, for instance virus protection, conspec. Preferrably also functions only evolution thinks of. I like to be surprised
I think properly implemented mutation protection should expand bot genomes, not limit them. Therefor evolution should be able to break it, or reuse it in some other way.
-
Ikke- Does it adequately present your viewpoint now?
Also, how difficult do you think your idea would be to implement? It might be difficult for me, since I'm not in CS, but maybe there's an easy way to do it that I'm not seeing.
-
I'm going with EricL idea. Possible together wih some costs, but not necesarily.
Oh, and I like some command that would decrease mutation-rates overall, like the propopal of storing a negative number in .mrepro that Numsgil did. Or maybe creating some kind of dna-fixing substance. Something that uses itself by undoing mutations. Atleast that the bots could gain a possibility to survive in high mutation enviroments.
Anyway my two cents. I'll gues I make the confusion bigger.
There isn't really a winner.
-
I'm going with EricL idea. Possible together wih some costs, but not necesarily.
Oh, and I like some command that would decrease mutation-rates overall, like the propopal of storing a negative number in .mrepro that Numsgil did. Or maybe creating some kind of dna-fixing substance. Something that uses itself by undoing mutations. Atleast that the bots could gain a possibility to survive in high mutation enviroments.
Anyway my two cents. I'll gues I make the confusion bigger.
There isn't really a winner.
Thanks for the 2 cents! We need as many comments as possible to see what everyone wants. And as many votes as possible, too!
Feel free to vote for your own idea, too, if you think it's the best.
Well, anyway, you could decrease mutation rate for the entire bot by making the mutation protection instruction apply for the entire genome. For example, if a bots' DNA is 100 bps long then putting
"100 .protect50 store"
at the top of the genome would halve the mutation rate for the entire bot. So, maybe I'm just not understanding your argument.
---
And no, there isn't a winner yet. I'm planning on leaving the poll going for a week, and next Saturday the idea voted for most, even if it wins by only one vote, will be submitted as the final suggestion to be implemented.
So, everyone, be sure to vote! It does count!
-
... at the top of the genome would halve the mutation rate for the entire bot. So, maybe I'm just not understanding your argument.
I had three different suggestions. Maybe not formulated perfectly in the earlier post. The second one could be implented anyway, it isn't too difficult, I think .
1. What Eric said.
2. Decrease mutations during reproduction by storing a negative number in .mrepro.(Original Numsgil idea)
3. Or maybe creating some kind of dna-fixing substance. Something that uses itself by undoing mutations. Atleast that the bots could gain a possibility to survive in high mutation enviroments.(I copy/paste it from my original post )
-
Let me rephrase the hash idea, because this is the one best fleshed out to me
- Allow genome alteration evaluation by means of a hashing function
- allow hash results to be stored in the genome
- allow a genome copying function in the genome
With these commands mutation protection can be built. The bonus is that the functions can also be used for other things.
The con for the level of genome mutation protection is wrong. Given adequate programming any level of protection can be estabished, and this can be done without duplicates. A duplicate is only needed if damage needs to be repaired. Furthermore it can be used to programme (conditional) increase mutation occurrence, and is therefor more flexible.
-
K, thanks ikke. Changed it in the original post. Is it alright now? Also, would you like for me to remove the original DNA-comparison idea from the poll?
Everyone, be sure to read the edited summaries to get a better idea of the proposals!
-
Could you explain how trying to protect the DNA more than once would cause the Mutation protection instructions to be overwritten? Also, how would you combine enzymatic protection with metadata?
Step One-Select code to be protected, and amount to be allocated to protected gene(as a ratio of total allocated protection), mutations to protect against (not necessary, just thought some mutations should be harder to prevent than others.)
[protect rate=60, type=delta]
...
[/protect]
Step Two-Protect, amount is spread in a ratio between all genes protected
100 .mkenzyme store
an alternative way to go is to share evenly, and define a threshold after which a gene will stop being protected. Enzymes will not stop mutations, but *for example) 50 units stop 50%, 100 units 70%, 200 units 80% etc.
-
Unfortunately I know very little about biology and I am new to darwinbots itself, but that’s never stopped me putting my 0.02 cents in before.
What is this feature trying to achieve? Is it protecting sub sets of hand coded DNA from changing in an otherwise mutating bot?
Or is it indented to allow a bot to evolve protection for vital areas of code mutating too often without needing to lower the simulation wide mutation rate?
If it’s the second, you might not want a bot to be able to evolve cost free protection since; it may appear to be slightly beneficial in the short term, stabilising a population by creating a larger proportion of fully functioning bots, especially if the simulation wide mutation rate is high, but might be damaging to the species in the long term, by drastically slowing its evolution.
Correct me if I am wrong but it feels like something that could accumulate and might not show its true detriment until many generations later by which time (by its very nature) would then be very hard for the bot to undo. If it had a cost from the start then each step would have to show real and immediate benefits in order for it to persist; only I am not sure that with costs attached it would show any tangible benefits in the short term, the benefits of this kind of targeted protection sound like long-term ones? Not forgetting that changes to things like feeding and reproduction will most likely become evolutionary dead-ends in very short order anyway.
-
... at the top of the genome would halve the mutation rate for the entire bot. So, maybe I'm just not understanding your argument.
I had three different suggestions. Maybe not formulated perfectly in the earlier post. The second one could be implented anyway, it isn't too difficult, I think .
1. What Eric said.
2. Decrease mutations during reproduction by storing a negative number in .mrepro.(Original Numsgil idea)
3. Or maybe creating some kind of dna-fixing substance. Something that uses itself by undoing mutations. Atleast that the bots could gain a possibility to survive in high mutation enviroments.(I copy/paste it from my original post )
Ok, now I see what you mean. I should've known that being tired would make me miss something you said!
Anyway, putting a negative number in .mrepro would just decrease the entire bots' mutation rate. What we were suggesting is finer-grained control, so that a bot can protect it's most important and fragile DNA (like living organisms do- when was the last time you heard of a dog that was born with a broken Krebs cycle? And, when was the last time you heard of a dog with an extra toe? One's much more common than the other, implying specific mutation protection for the important genes.)
Also, by having something that uses itself by undoing mutations, do you mean bacillus' idea of an enzyme that has a cost associated with it? You don't actually mean deleting the instruction from the offspring when used by the parent, do you?
And correct me if I'm wrong, but numsgil wanted codules, not negative .mrepro instructions. In fact, he thinks there shouldn't be any metadata in the DNA at all. Look at the link to the DB3 topic in the first post above.
---
Cyberduke:
Both are reasons for the Mutation Protection. We know living organisms protect their DNA. For example, when was the last time you heard of a dog that was born with a broken Krebs cycle? And, when was the last time you heard of a dog with an extra toe? One's much more common than the other, implying specific mutation protection for the important genes.
If a bot is in a difficult environment, then it would be better for it to have a good chance of mutating, so it can evolve. But once it has reached a local maxima, where most further mutations will harm it rather than help it, then it should protect it's DNA from further mutation, instead of constantly breaking itself. Once the environment changes, it would be best for it to re-allow mutation, to find the local maxima once more.
So, I don't think that cost-free mutation protection would slow evolution, since the bots with no-mutations-allowed will die out in a new environment, while the ones that allow mutations will probably survive.
So, I'm thinking mutating does have a short-term benefit.
However, I am starting to like the cost idea too. Maybe free mutation protection will be a problem.
So, anyway, I'm guessing you voted for bacillus' original idea?
-
Both are reasons for the Mutation Protection. We know living organisms protect their DNA. For example, when was the last time you heard of a dog that was born with a broken Krebs cycle? And, when was the last time you heard of a dog with an extra toe? One's much more common than the other, implying specific mutation protection for the important genes.
This is not because core metabolic pathways are protected. It's because almost all mutations in them break the organism so bad that they never get born in the first place. Or at least, that's the central theory to modern evolutionary thought. Since about the mid 80s there's been some thought about organisms directing their own mutations somewhat in response to evolutionary pressure. So this feature lives only to please whoever wants it, not to satisfy realism.
-
Anyway, putting a negative number in .mrepro would just decrease the entire bots' mutation rate. What we were suggesting is finer-grained control, so that a bot can protect it's most important and fragile...
Yes, I was putting in a more global suggestion inside it. If bots are save and sound they can lower the whole mutation rate. If they are endangered they can higher the mutation by making it a positive number. That together with some protected genes can come to steared mutation of parts.
DNA (like living organisms do- when was the last time you heard of a dog that was born with a broken Krebs cycle? And, when was the last time you heard of a dog with an extra toe? One's much more common than the other, implying specific mutation protection for the important genes.)
Cyberduke:
Both are reasons for the Mutation Protection. We know living organisms protect their DNA. For example, when was the last time you heard of a dog that was born with a broken Krebs cycle? And, when was the last time you heard of a dog with an extra toe? One's much more common than the other, implying specific mutation protection for the important genes.
Used copy/paste huh.
Also, by having something that uses itself by undoing mutations, do you mean bacillus' idea of an enzyme that has a cost associated with it? You don't actually mean deleting the instruction from the offspring when used by the parent, do you?
Yes, that could be. Some ''enzyme'' that undoes mutations. I could have missed it, but I thought bacillus idea wasn't really the same. I'd go for Eric idea for this one anyway.
And correct me if I'm wrong, but numsgil wanted codules, not negative .mrepro instructions. In fact, he thinks there shouldn't be any metadata in the DNA at all. Look at the link to the DB3 topic in the first post above.
Well in the other topic he made a quick notion of it. So that is how it became Numsgil idea.
-
It was something I did for the C++ branch. mrepro, instead of causing reproduction, would influence mutation rates of the next .repro event. negative values decreased mutation rates, positive numbers increased mutation rates. I think there was a cost/benefit associated with it (negative values cost time or nrg, positive values save time or nrg).
-
Numsgil:
Alright, maybe that was a bad example. But anyway, you know what I mean.
Also, are you saying that .mrepro was not in the main VB DB?
Peter:
Yes, but what I was saying is that a bot could put it's whole genome inside the mutation protection instruction/codule, and therefore could protect/enhance mutation rates for the entire genome. This is what you wanted, right?
And ya, I admit, I copied and pasted as well. Rushed
Cyberduke:
Anyway, I hope I clarified. Look here: http://en.wikipedia.org/wiki/DNA_repair#Ra...utionary_change (http://en.wikipedia.org/wiki/DNA_repair#Rate_of_evolutionary_change)
for a bit more info.
-
mrepro exists in the current version, but it works like .repro does. The value represents the % of your resources the child gets. I changed it so mrepro worked as a modifier to .repro instead of working independently. But it never made it in the VB code.
-
Peter:
Yes, but what I was saying is that a bot could put it's whole genome inside the mutation protection instruction/codule, and therefore could protect/enhance mutation rates for the entire genome. This is what you wanted, right?
Well, using negative .mrepro would then only protect during reproduction. The genome after the protection instruction would be protected by all kind of mutations. So that is the only difference.
-
Peter:
Yes, but what I was saying is that a bot could put it's whole genome inside the mutation protection instruction/codule, and therefore could protect/enhance mutation rates for the entire genome. This is what you wanted, right?
Well, using negative .mrepro would then only protect during reproduction. The genome after the protection instruction would be protected by all kind of mutations. So that is the only difference.
Well, as far as I know, point mutations are the only mutations that do not occur during reproduction. So, point mutations should be the only difference between -x.mrepro and putting everything inside the mutation protection codule/instruction. And, as far as I know, organisms can repair point mutations as well- see here: http://en.wikipedia.org/wiki/Direct_DNA_damage (http://en.wikipedia.org/wiki/Direct_DNA_damage)
So, I still think there should be no difference.
However, maybe we should add a tiny amount of point mutations that none of the mutation protection methods, even on max setting, can protect against. This might be more realistic. However, that would rule out certain applications of this feature, where you need 100% protection from everything.
By the way, what should we do about viruses? I think mutation protection should be hapless against protecting from viruses, but that eliminates the ability to protect the DNA from anything, which some people might want for certain cases. What do you think?
mrepro exists in the current version.
...
But it never made it in the VB code.
Do you mean it's in the current version of the C++ DB?
-
Well, as far as I know, point mutations are the only mutations that do not occur during reproduction. So, point mutations should be the only difference between -x.mrepro and putting everything inside the mutation protection codule/instruction. And, as far as I know, organisms can repair point mutations as well- see here: http://en.wikipedia.org/wiki/Direct_DNA_damage (http://en.wikipedia.org/wiki/Direct_DNA_damage)
So, I still think there should be no difference.
The .mrepro was just a little suggestion I made (took over from numsgil). I won't make a big point getting it inplemented or not. As I like Eric-idea overall better anyway. It wouldn't have an effect on the other ways trough. So it wouldn't couse any trouble if would be too implented.
However, maybe we should add a tiny amount of point mutations that none of the mutation protection methods, even on max setting, can protect against. This might be more realistic. However, that would rule out certain applications of this feature, where you need 100% protection from everything.
Just a percentage of mutations that get through that was the original setting too, right.
You get dna-mutations anyway. Any small mistake that could ever happen in RAM and change the dna.
By the way, what should we do about viruses? I think mutation protection should be hapless against protecting from viruses, but that eliminates the ability to protect the DNA from anything, which some people might want for certain cases. What do you think?
Maybe slime..
mrepro exists in the current version.
...
But it never made it in the VB code.
Do you mean it's in the current version of the C++ DB?
Nope,
mrepro exists in the current version, but it works like .repro does. The value represents the % of your resources the child gets. I changed it so mrepro worked as a modifier to .repro instead of working independently. But it never made it in the VB code
VB .mrepro couses normal reproduction exept it creates a mutated child.
C++ .mrepro changes the mutation rate of a reproduction. This never made it in VB.
C++ is disbanded anyway trough.
-
However, maybe we should add a tiny amount of point mutations that none of the mutation protection methods, even on max setting, can protect against. This might be more realistic. However, that would rule out certain applications of this feature, where you need 100% protection from everything.
Just a percentage of mutations that get through that was the original setting too, right.
You get dna-mutations anyway. Any small mistake that could ever happen in RAM and change the dna.
By the way, what should we do about viruses? I think mutation protection should be hapless against protecting from viruses, but that eliminates the ability to protect the DNA from anything, which some people might want for certain cases. What do you think?
Maybe slime..
Well, I was trying to find a way to implement what I thought you were suggesting. To be honest, I think only having the regular mutation protection without .mrepro will suffice.
You're right- slime works. I never investigated slime before... Just forget I ever asked that.
-
I just mentioned what I did with mrepro because it's somewhat related to what we're talking about. I'm not trying to suggest that it's a replacement for any of the other ideas talked about; it serves a different purpose.
-
So, apparently we're going to implement a hybrid: Eric's instruction idea with costs, assuming the polls don't change. Although I was hoping that we would get enough votes for us to find that a statistically significant portion of the DB users wanted choice x, because with 6 votes you can't say much about what 3,000 users want, but maybe we can implement the losing ideas once we get the winner working, so it can still be fair ultimately.
I wonder why only 6 people voted... I'd appreciate criticism here...
-
So, apparently we're going to implement a hybrid: Eric's instruction idea with costs, assuming the polls don't change. Although I was hoping that we would get enough votes for us to find that a statistically significant portion of the DB users wanted choice x, because with 6 votes you can't say much about what 3,000 users want, but maybe we can implement the losing ideas once we get the winner working, so it can still be fair ultimately.
I wonder why only 6 people voted... I'd appreciate criticism here...
I would think becouse there aren't 3000 people. I think there where only a few people who visited last time. My little league-poll also has just 7 people, there aren't that much. I gues you can figure out there are only a few active on this forum.
And I think that the idea of eric is not harder implent then the others. So making more implementation of ideas would be a waste of time anyway. The list of Eric is long enough anyhow.
-
Hi peter,
Thanks for pointing that out. I changed the summaries in the first post now.
I once read somewhere that DB2.44 had been downloaded 3000 times, so that's where 3000 came from.
Anyway, I don't think the problem is that we have only a few people who use the forum. I mean, it's been viewed 182 times.
-
And how many of those would have a strong opinion in this matter
-
And how many of those would have a strong opinion in this matter
LOL- Good point
By the way, could you explain how trying to protect the DNA more than once would cause the Mutation protection instructions to override previous attempts? If you mean that genes after the most recent Mutation protection instruction can only be in that instruction's scope, I don't see how that's a problem. This may be important, since eric's protection instruction idea is winning.
-
It's like having code that says:
2.up store
..
5 .up store
the second command would override the first one. If multiple genes invoke .protect, only one of them will resolve at any one time, unless we are going to resolve it while reading through the DNA (which I am not too fond of). It's the same reason 0 .delgene at the end of the DNA works.
And by the way, it seems like my original idea is winning, although if I could, I'd go back and change my vote.
-
It's like having code that says:
2.up store
..
5 .up store
the second command would override the first one. If multiple genes invoke .protect, only one of them will resolve at any one time, unless we are going to resolve it while reading through the DNA (which I am not too fond of). It's the same reason 0 .delgene at the end of the DNA works.
And by the way, it seems like my original idea is winning, although if I could, I'd go back and change my vote.
So, if I understand you correctly, your concern is that a certain stretch of code will only be affected by the most recent mutation protection instruction. This is true of all the submissions, even metacode, and is what we wanted to begin with. It's also most like real-life biology. And why would someone want to combine/multiply/do_something_else the mutation rates if it's nested in multiple mutation protection instructions? The whole reason for putting a mutation protection instruction inside a mutation protection instruction is so that some code will not be affected by the outer mutation protection instruction. So why is this a problem?
2: Well, your original idea is winning, but it just says "make mutation protection have a cost", which is too vague to be a formal submission. Eric's idea is the only well-defined submission that's winning, so that's why eric's idea + costs is so far the winner.
By the way, what would you change your vote to? I'll factor in your new vote for when we finally decide.
Also, I know eric didn't vote, so maybe we should count in his vote as pro-eric?
Also also, I am officially abbreviating Mutation protection instruction as MPI. Tired of typing mutation protection instruction over and over...
EDIT: Announcement: The last day has been changed from Saturday to whenever Eric gets back.
-
It's all pretty moot if Eric never shows. Remember he's the one that ultimately implements things, and he seems to be AWOL.
-
Does he usually leave for long stretches of time? If he's gone, who will update darwinbots?
-
No, not really. And if he is gone nobody is updating darwinbots. He is vital for the inprovement of darwinbots.
-
He leaves for summer, when he spends time with his family. I thought that was up, but maybe not.
-
He leaves for summer, when he spends time with his family. I thought that was up, but maybe not.
Oh, OK. Sorry eric- Didn't know that.
-
I'd change to my new idea; I'm really fond of the concept of tagging on metadata, as it can be handled seperately to regular DNA, so won't really require the stack/memory.
EDIT=>I did actually provide specifics with my idea, the difference between it being a concept and what actually happened was that no-one understood it/ignored it.
-
In reply to 3.), it simple represents an effective 'mutation-immunity' system becoming ineffective over time, and needing refreshing. The major issue (note that this is not the only suggestion that has this issue) is that it relies on the data being stored in a memory location; multiple attempts at protecting DNA will override previous attempts, therefore the way to go will eventually be in the form of metadata. Based on that, I'd change my suggestion to combine the metatag suggestion with the protective enzyme protection system, which also gives a way to control the costs of protecting DNA. (in nrg per unit produced, evenly distributed within the tags, or perhaps allocated by a variable)
EDIT=>Don't forget that most people invloved in this discussion put forward an idea themselves, so I'd be surprised if there is a clear winner
I'm sorry if I misunderstood your original suggestion- this is the most detailed overview of it I could find. As far as I can see, it mentions:
1: Mutation protection degrades over time. (In suggestion summary)
2: Relies on data being stored in memory. (I put in the suggestion summary that it's not metadata, which is the same, right?)
3: DNA is protected by most recent MPI. (I thought this was obvious- as far as I know, we want things to be affected only by the most recent MPI, because it's in it's scope. I don't see why we'd want something different.)
So, please let me know of what I missed.
-
I'll start again:
Step 1-make enzyme. This will act the same way as slime does, decaying over time, more enzyme provides more protection eg reduce chance of mutatoins
Step 2-use X .protect store; if X is negative, it will protect X bps before the command, if positive, the next X bps after the command. The bigger the size of code protected, the faster enzymes wear off.
Note that I later changed Step 2 to tagging with metadata, which allows multiple protects in one cycle (not sure about logic though), and the distribution of substances.
-
I'll start again:
Step 1-make enzyme. This will act the same way as slime does, decaying over time, more enzyme provides more protection eg reduce chance of mutatoins
Step 2-use X .protect store; if X is negative, it will protect X bps before the command, if positive, the next X bps after the command. The bigger the size of code protected, the faster enzymes wear off.
Note that I later changed Step 2 to tagging with metadata, which allows multiple protects in one cycle (not sure about logic though), and the distribution of substances.
OK, I understand now. I think you summarized it well, so I just copied/pasted. Done.
Thanks!!
-
Whee, some one understood me for once
-
Ok, Nums and Eric (and Bacillus' first idea, if you count that B changed his vote to his new idea) are tied...
If we ultimately end up with a tie/one vote difference between ideas, maybe we should combine them. Then again, people might like the hybrid less...
We could implement both, but that might take too long...
If this continues, then maybe we should count bacillus' old idea as being a variation of eric's, since it basically is just eric's idea with costs. So, eric's supporters are really the ones who voted for eric AND the ones who voted for B's old idea. In that case, we'll make B's old idea the winner, but make the costs optional.
So far, this is what it looks like:
---Settings------
- Turn on Mutation protection?
- Turn on Mutation protection costs?
-------------------
0: 10 .protect store '(protects self)
...12345678... '(protects next nine BPs)
9: 100 .mkprotenzyme store '(make the most recent .protect instruction give 100% mut protection, which costs 100/50 or 2 nrg per cycle per BP (10 nrg/cycle in this case), and whose cost increases exponentially over time OR ...and whose mutation protection decreases by 1 per cycle)
--AND--
---Settings------
- Turn on Mutation protection?
[] Turn on Mutation protection costs?
-------------------
0: 10 .protect store '(protects self)
...12345678... '(protects next nine BPs)
9: 100 .mkprotenzyme store '(make the most recent .protect instruction give 100% mut protection, with no costs/degradation)
This should make a little under 2/3 of the users happy, judging by the polls. The first case is good for evosims, the second for antbot or NNbot evolution/leagues-with-NN-weight-adjustment.
-
OK, apparently the vote's over- no one has voted to change anything since my last post in mid-october, so numsgil:
It says the suggestions forum is led by both you and ericl- can you implement the mutation protection as described in my last post, since eric has disappeared?
By the way, to the new users (peterb, de-evo, etc...), feel free to vote!
-
It's all pretty moot if Eric never shows. Remember he's the one that ultimately implements things, and he seems to be AWOL.
Is only one person devolping DarwinBots ?
I have some knowledge on programming languages.
Well that is I'll easily pickup such languages often.
Dough I never went deep into them ( these days I get headaches from looking long at code)
Anyway I went from :
MSX assembler / Pascal / QuickBasic / VB6 / VB2003.net / C# (pocketpc) / C2003.net / Perl (little) / phyton (little) / LSL / vbscrip / VB2008.net
And maybe some more lost track of it a bit.
Dough I'm not a big fan of C languages, takes lots of time to write and read while VB.net is equaly fastand better readable.
Time might be the biggest issue dough.
I hope a project like this is structured / devided ?? >> I'm not sure how it is organised but it might be an idea to put source code in a special forum folder (so people could reply with improved code.. (and discuss their distributed programing efforts).
-
Different idea.
Well different, I'm not sure I think DNA rampage by mutation often results in something supricingly
Yesterday one of my zerobot sudenly became a better hunter dough sadly also a canibal what I had tried to not to become.
Thiking about it a bot described by 1 gene, errors would happen and effect everything equaly inside that gene.
If a bot has multiple genes, like most bots; Then what genes would most likely mutate?
> maybe the smaller (so to say specialized)ones
> or making it depending on the seize of the cond fields (to give to verry advanced super eye commands some penalties?)
> or making it depending on the start stop seize
> or depending on the general gene size lengthe
> or based on how often genes fire
On multibots perhaps something that preserves body-bot specification (based on how often genes fire ?)
On zero bots... hmmm I got no idea ....
just a side to note that bots can change type from zerobot to 1 gene bot to multiple gene bot to multibot > all diffferent structures > different rules?
Dough on the otherhand sometimes you create a bot and wonder only what if the numbers in that Cond part would change.
It might be programmable over generations
Then perhaps just have some kind of flag commands
like :
1 .flagcommanderrors store
1 .flagvaleuerrors store
1 .flagallerrors store
=========>> or .DNAerrortype: -1 for numbers, 0 for both, 1 for commands
5 .flagpreserve store (preserves the next 5 code lines for mutation)
5 .flagmutate store (the oposite)
*.flagprotectedbits (how much bits are protected)
*.refprotectedbits (as ref command so you like to preserve?, then also others can identify you (or rather that is your famliy) by it
*.refunprotectedbits (maybe thats to much).
When using flagmutate Then it would impley that the rest could mutate.
Maybe put a cost to it too per cycle; the cost would depend on the number of bits protected by it seams fair
Or we would all make zero bots; close to oneliners
Maybe have something that more advanced creatures (more genes, more connected bots) have a better effect of it.
Would be like an evolution upward step and so have less error risk? (or maybe the oposite?)
DNA lesserrorriskfactors, overal bot gene:
*.numties *.numgenes sum *.shell sum
A shell also has UV protection from light so less errors son only in pond mode add *.depth)
*.numties *.numgenes sum *.shell sum sum *.depth sum
~maybe minus the amount of poison inside as that is dangerous stuff to handle, even for the creature itself.
Wow I'm a long speaker I notice, dough I think those are nice ideas concluding it would result like:
So the bigger the more advanced the more protection dough also a higher cost. (and can be dependant of pond height).
I dont know if this command would be a problem for the stack ?
As it could stand before a gene [cond] but also inside a gene [cond] or in the [start] part.
-
10 .flagpreserve store is pretty much the exact same thing as 10 .protect store. I think you're basically saying the same thing as the Ericl and Bacillus hybrid (which became the final draft of the idea), you're saying to make an instruction to protect DNA as opposed to metadata, plus costs. If you read through the posts, you'll see this was bacillus's original idea.
However, the refprotectedbits instruction seems like it might be able to address some of the problems the metadata camp was having with eric's idea- namely, treating the protected DNA as a single object vs. a wad of instructions.
Nums- what do you think?
-
It's all pretty moot if Eric never shows. Remember he's the one that ultimately implements things, and he seems to be AWOL.
Is only one person devolping DarwinBots ?
I have some knowledge on programming languages.
Well that is I'll easily pickup such languages often.
Dough I never went deep into them ( these days I get headaches from looking long at code)
Anyway I went from :
MSX assembler / Pascal / QuickBasic / VB6 / VB2003.net / C# (pocketpc) / C2003.net / Perl (little) / phyton (little) / LSL / vbscrip / VB2008.net
And maybe some more lost track of it a bit.
Dough I'm not a big fan of C languages, takes lots of time to write and read while VB.net is equaly fastand better readable.
Time might be the biggest issue dough.
I hope a project like this is structured / devided ?? >> I'm not sure how it is organised but it might be an idea to put source code in a special forum folder (so people could reply with improved code.. (and discuss their distributed programing efforts).
Eric's the only one developing on the current version, which is written in VB6. I guess he's moved on to other things, I'll send him an email for the source code at some point.
Other people have worked on a new version in C#, but it's not very far, and I haven't worked on it for a while since I've been busy with work. The C# version is source controlled, so you can browse it with a web browser.
-
10 .flagpreserve store is pretty much the exact same thing as 10 .protect store. I think you're basically saying the same thing as the Ericl and Bacillus hybrid (which became the final draft of the idea), you're saying to make an instruction to protect DNA as opposed to metadata, plus costs. If you read through the posts, you'll see this was bacillus's original idea.
However, the refprotectedbits instruction seems like it might be able to address some of the problems the metadata camp was having with eric's idea- namely, treating the protected DNA as a single object vs. a wad of instructions.
Nums- what do you think?
I don't like having the DNA be able to influence itself like that, even through the stack. This isn't me speaking as a developer, just as a user. I prefer mutation rates to be an inherent property of a given bp, instead of inserted mid stream. DNA being able to influence itself like that is a path that leads to things like DNA manually copying itself during reproduction as with Avida, which is a valid path for ALife in general but not the direction I want to see Darwinbots head in.
-
Just as a minor afterthought I thought would be worth throwing in, what if protection did not protect against a certain mutation, or over a range of DNA, but a range of values? Don't look into this too far, just a thought I thought worth mentioning.
-
10 .flagpreserve store is pretty much the exact same thing as 10 .protect store. I think you're basically saying the same thing as the Ericl and Bacillus hybrid (which became the final draft of the idea), you're saying to make an instruction to protect DNA as opposed to metadata, plus costs. If you read through the posts, you'll see this was bacillus's original idea.
However, the refprotectedbits instruction seems like it might be able to address some of the problems the metadata camp was having with eric's idea- namely, treating the protected DNA as a single object vs. a wad of instructions.
Nums- what do you think?
I don't like having the DNA be able to influence itself like that, even through the stack. This isn't me speaking as a developer, just as a user. I prefer mutation rates to be an inherent property of a given bp, instead of inserted mid stream. DNA being able to influence itself like that is a path that leads to things like DNA manually copying itself during reproduction as with Avida, which is a valid path for ALife in general but not the direction I want to see Darwinbots head in.
Perhaprs two ideas why it is nice to have it as a general command.
In nature some DNA parts are more preserved then others, and thats organized whitin the DNA itself (so it 'll be more like nature).
For example people come with various eyecolors dough you see rarely a human with 5 eyes. So beeing able to preserve parts isnt that strange.
On the otherhand it would also be nice to for example have a bot for who you only would which to evolve better eyes.
(then have also something to decide against what DNS errors you want to be protected (valeus / commands / both )
Hmmm VB6.....
Is conversion to VB.net possible ? (C# isnt mostly not that much faster, as anyother complete groundup rebuilds.)
It might require tools to convert which I dont have....
-
Nums-
You know eric, IRL? Do you know what's going on? Will DB rot and remain at 2.44 until DB3 comes out?
-
10 .flagpreserve store is pretty much the exact same thing as 10 .protect store. I think you're basically saying the same thing as the Ericl and Bacillus hybrid (which became the final draft of the idea), you're saying to make an instruction to protect DNA as opposed to metadata, plus costs. If you read through the posts, you'll see this was bacillus's original idea.
However, the refprotectedbits instruction seems like it might be able to address some of the problems the metadata camp was having with eric's idea- namely, treating the protected DNA as a single object vs. a wad of instructions.
Nums- what do you think?
I don't like having the DNA be able to influence itself like that, even through the stack. This isn't me speaking as a developer, just as a user. I prefer mutation rates to be an inherent property of a given bp, instead of inserted mid stream. DNA being able to influence itself like that is a path that leads to things like DNA manually copying itself during reproduction as with Avida, which is a valid path for ALife in general but not the direction I want to see Darwinbots head in.
Perhaprs two ideas why it is nice to have it as a general command.
In nature some DNA parts are more preserved then others, and thats organized whitin the DNA itself (so it 'll be more like nature).
For example people come with various eyecolors dough you see rarely a human with 5 eyes. So beeing able to preserve parts isnt that strange.
It's not the protection of DNA I don't like, it's having the protection be coded inside the DNA. To me, instead of doing something that protects the next 25 bps, or whatever, those 25 bps would be protected because of some intrinsic property they have. That way, the command that protects the next 25 bps won't potentially get separated from the 25 bps it's meant to protect. It's just a gut feeling, I can't totally rationalize it. I just think that having the DNA be able to influence its physical structure is a slippery slope. We as coders should be able to, and mutations should be able to, but it should be on a different level.
Hmmm VB6.....
Is conversion to VB.net possible ? (C# isnt mostly not that much faster, as anyother complete groundup rebuilds.)
It might require tools to convert which I dont have....
It's possible, but it might as well be a conversion to C. VB6 and VB.net are totally different, and it's a non trivial amount of effort to convert Darwinbots to use .net. Eric was working on it, IIRC, but I don't remember how far he got.
Nums-
You know eric, IRL? Do you know what's going on? Will DB rot and remain at 2.44 until DB3 comes out?
Not in person, but I have his email. I'll shoot him an email and see what's up.