如何确定基因组的特征? [英] How to determine characteristics for a genome?
问题描述
在AI中，是否存在任何简单和/或非常直观的示例来说明如何将基因组实施到模拟中?
In AI, are there any simple and/or very visual examples of how one could implement a genome into a simulation?
基本上，我只是经过一个简单的演练(不是教程，而是某种概括性的内容)，其中详细介绍了如何实现以求和方式改变个体"特征的基因组.
Basically, I'm after a simple walkthrough (not a tutorial, but rather something of a summarizing nature) which details how to implement a genome which changes the characteristics in an 'individual' in a sumlation.
这些基因不会是这样的:
- 质量
- 实力
- 长度
- 等等.
相反，它们应该是定义上述内容，从模拟居民的实际特征中提取基因组.
But rather they should be the things defining the above things, abstracting the genome from the actual characteristics of the inhabitants of the simulation.
我清楚我想要什么吗?
Anyway, if there's any way that you have tried that's better, and that implements evolution in a form like these sexual swimmers, then by all means, go ahead and post it! The more fun inspiration the better :)
推荐答案
如果您自己实现个人"，那么任何对象都可以充当您的基因组.
If you are implementing your 'individuals' yourself then any object can act as your genome.
特征
一种进一步简化此方法的方法是将您的特征转换为枚举.这样，您可以通过从父母的基因中选择特征进行简单的重组，并通过随机选择特征的枚举值之一来突变基因.
One way to simplify this further is to turn your characteristics into enums. This way you can have a simple recombination of the parent's genes by selecting characteristics from them and a mutation of the gene by random selection of one of the enum values for a characteristic.
一旦成功，您可以在值范围上获得更多细微差别，但是使用枚举可以帮助我起初保持清楚.
Once this is working you can get more nuanced with value ranges but using enums helps me keeps things clear at first.
健身
然后要赋予这些特征，意味着您需要一个描述性能的健身功能.特性之间的关系取决于您，因此您可以用任何有意义的方式对其进行描述.这只是比较两个基因组的一致方法.
Then to give these characteristics meaning you need a fitness function that describes performance. The relationship between the characteristics is up to you so you can describe it in any way that makes sense. This just provides a consistant way to compare two genomes.
模拟
然后运行模拟只是从几个父母开始，然后生成一堆孩子以彼此完成.这当然可以自动化，但这是一个明确的示例.
Then to run a simulation just start with a few parents and generate a bunch of children to complete with each other. This can of course be automated but here is an explicit example for clarity.
Java示例
import java.util.PriorityQueue;
class Genome implements Comparable<Genome> {
public enum Mass {
LIGHT(1),
AVERAGE(2),
HEAVY(3);
final Integer value;
Mass(Integer value) {
this.value = value;
}
}
public enum Strength {
WEAK(1),
AVERAGE(2),
STRONG(3);
final Integer value;
Strength(Integer value) {
this.value = value;
}
}
public enum Length {
SHORT(1),
AVERAGE(2),
LONG(3);
final Integer value;
Length(Integer value) {
this.value = value;
}
}
private final Mass mass;
private final Strength strength;
private final Length length;
public Genome(Mass mass, Strength strength, Length length) {
this.mass = mass;
this.strength = strength;
this.length = length;
}
private Integer fitness() {
return strength.value * length.value - mass.value * mass.value;
}
@Override public int compareTo(Genome that) {
// notice the fitter is less in precedence
if(this.fitness() > that.fitness())
return -1;
else if(this.fitness() < that.fitness())
return 1;
else // this.fitness() == that.fitness()
return 0;
}
public static Genome recombine(Genome... parents) {
if(parents.length < 1)
return null;
// Select parents randomly and then characteristics from them
Mass mass = parents[(int)(Math.random() * parents.length)].mass;
Strength strength = parents[(int)(Math.random() * parents.length)].strength;
Length length = parents[(int)(Math.random() * parents.length)].length;;
return new Genome(mass, strength, length);
}
public static Genome mutate(Genome parent) {
// Select characteristics randomly
Mass mass = Mass.values()[(int)(Math.random() * Mass.values().length)];
Strength strength = Strength.values()[(int)(Math.random() * Strength.values().length)];
Length length = Length.values()[(int)(Math.random() * Length.values().length)];
return new Genome(mass, strength, length);
}
public static void main() {
PriorityQueue<Genome> population = new PriorityQueue<Genome>();
Genome parent1 = new Genome(Mass.LIGHT, Strength.STRONG, Length.SHORT);
Genome parent2 = new Genome(Mass.AVERAGE, Strength.AVERAGE, Length.AVERAGE);
Genome parent3 = new Genome(Mass.HEAVY, Strength.WEAK, Length.LONG);
population.add(parent1);
population.add(parent2);
population.add(parent3);
Genome child1 = Genome.recombine(parent1, parent2);
Genome child2 = Genome.recombine(parent1, parent2);
Genome child3 = Genome.recombine(parent1, parent3);
Genome child4 = Genome.recombine(parent1, parent3);
Genome child5 = Genome.recombine(parent2, parent3);
Genome child6 = Genome.recombine(parent2, parent3);
Genome child7 = Genome.recombine(parent1, parent2, parent3);
Genome child8 = Genome.recombine(parent1, parent2, parent3);
Genome child9 = Genome.recombine(parent1, parent2, parent3);
child1 = Genome.mutate(child1);
child2 = Genome.mutate(child2);
child4 = Genome.mutate(child4);
child8 = Genome.mutate(child8);
population.add(child1);
population.add(child2);
population.add(child3);
population.add(child4);
population.add(child5);
population.add(child6);
population.add(child7);
population.add(child8);
population.add(child9);
// and the winner is...
Genome fittest = population.peek();
}
}
编码
由于听起来您想将特征编码为一个序列，该序列具有在序列中显式的某些特征以及从这些特征派生的其他特征.
Since it sounds like you want to encode the characteristics into a sequence having some characteristics explicit in the sequence and others derived from those.
您可以这样做，例如将上述值的枚举编码为整数，并用大块表示您的显式特征.
You can do this my encoding your rangle of values, like the enums above, into an integer with chunks representing your explicit characteristics.
例如，如果您有两个具有四个可能值的显式特征，则可以将该集合编码为00XX + XX00形式的整数.因此，例如0111可能对应于质量01和长度11.这样做是让您通过更改序列本身中的位来进行变异.
For example if you have two explicit characteristics with four possible values each you may encode the set as an integer in the form of 00XX + XX00. So for example 0111 might corresponds to a mass of 01 and a length of 11. What this does is let you mutate by changing the bits within the sequence itself.
Java示例
import java.util.PriorityQueue;
class Genome implements Comparable<Genome> {
private final Integer sequence;
private static final Integer bitmaskChunk = 3; // ...0011
private static final Integer shiftMass = 0; // ...00XX
private static final Integer shiftLength = 2; // ...XX00
private static final Integer shiftModulus = 4; // ...0000
private Integer getMass() {
return (sequence >>> shiftMass) & bitmaskChunk;
}
private Integer getLength() {
return (sequence >>> shiftLength) & bitmaskChunk;
}
public Integer getStrength() {
return getMass() * getLength();
}
public Genome(Integer sequence) {
this.sequence = sequence % (1 << Genome.shiftModulus);
}
private Integer fitness() {
// Some performance measure
return getStrength() * getLength() - getMass() * getMass();
}
@Override public int compareTo(Genome that) {
// notice the fitter is less in precedence
if(this.fitness() > that.fitness())
return -1;
else if(this.fitness() < that.fitness())
return 1;
else // this.fitness() == that.fitness()
return 0;
}
public static Genome recombine(Genome... parents) {
if(parents.length < 1)
return null;
Integer sequence = 0;
// Select parents randomly and then characteristics from them
sequence += parents[(int)(Math.random() * parents.length)].getMass() << Genome.shiftMass;
sequence += parents[(int)(Math.random() * parents.length)].getLength() << Genome.shiftLength;
return new Genome(sequence);
}
public static Genome mutate(Genome parent) {
Integer sequence = parent.sequence;
// Randomly change sequence in some way
sequence *= (int)(Math.random() * (1 << Genome.shiftModulus));
return new Genome(sequence);
}
public static void main() {
PriorityQueue<Genome> population = new PriorityQueue<Genome>();
Genome parent1 = new Genome((int)(Math.random() * (1 << Genome.shiftModulus)));
Genome parent2 = new Genome((int)(Math.random() * (1 << Genome.shiftModulus)));
Genome parent3 = new Genome((int)(Math.random() * (1 << Genome.shiftModulus)));
population.add(parent1);
population.add(parent2);
population.add(parent3);
Genome child1 = Genome.recombine(parent1, parent2);
Genome child2 = Genome.recombine(parent1, parent2);
Genome child3 = Genome.recombine(parent1, parent3);
Genome child4 = Genome.recombine(parent1, parent3);
Genome child5 = Genome.recombine(parent2, parent3);
Genome child6 = Genome.recombine(parent2, parent3);
Genome child7 = Genome.recombine(parent1, parent2, parent3);
Genome child8 = Genome.recombine(parent1, parent2, parent3);
Genome child9 = Genome.recombine(parent1, parent2, parent3);
child1 = Genome.mutate(child1);
child2 = Genome.mutate(child2);
child4 = Genome.mutate(child4);
child8 = Genome.mutate(child8);
population.add(child1);
population.add(child2);
population.add(child3);
population.add(child4);
population.add(child5);
population.add(child6);
population.add(child7);
population.add(child8);
population.add(child9);
// and the winner is...
Genome fittest = population.peek();
}
}
我希望这是您要寻找的.祝你好运.
I hope this is what you are looking for. Good luck.
这篇关于如何确定基因组的特征?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
