Question

我试图在java中实现roullete轮。

我创建了两种方法。一种是制造柔性轮，另一种是旋转柔性轮。

我应该如何实施probalibities。我的方法不是这样做的。我创建柔性轮的方法是完全错误的。

例如，如果我得到：

50％的染色体与健康86

35％的染色体与健康88

15％的染色体与健康90

如何确保15％的人有更多机会被选中？

    public void createRolette(Population population) throws Exception {

    int swap;

       for (int i=0; i<populationSize; i++){
           population.getIndividual(i);
           Simulator.allocateTask(i);
           rouletteId.add(i); 
           rouletteFit.add(calcFitness(i)); 
       }   


       for (int i = 0; i < rouletteFit.size() - 1; i++) {
           for (int j = 0; j < rouletteFit.size() - i - 1; j++) {
                if (rouletteFit.get(j) > rouletteFit.get(j+1))
                {
                    swap = rouletteFit.get(j);
                    rouletteFit.set(j, rouletteFit.get(j+1));
                    rouletteFit.set(j+1, swap);

                    swap = rouletteId.get(j);
                    rouletteId.set(j, rouletteId.get(j+1));
                    rouletteId.set(j+1, swap);
                }
          }
        }    
        System.out.println(rouletteId.toString());
        System.out.println(rouletteFit.toString());

        }



        public int rotateRolette(Population population) {           
               Integer SelectedIndv = (int)(Math.random()* (rouletteId.size())); // faz a escolha entre 0 e o numero maximo de elementos; 
               return rouletteId.get(SelectedIndv);
        }

Answer 1

我不确定你的代码是做什么的。但对于轮盘赌轮，你应该做这样的事情：

创建一个数组以将所有适合度值放入
计算所有人的适合度并将其保存在数组中
计算所有适合度值的总和，并将每个适合度除以该总和（标准化）
使用累计总和创建一个数组。对于实例：对于适应度值[0.1,0.2,0.3.0.4]，您的数组应为[0.1,0.3,0.6,1.0]
画一个数字[0,1]
使用累积和值循环遍历数组，并找到大于随机值的第一个值。 ID是您个人的ID。例如：如果您绘制0.05，您的ID将为0（第一个人）。如果你画0.8，你的ID应该是3（最后一个人）

Answer 2

前一个答案中描述的步骤的可能实现（使用Java 8）：

class RouletteWheelSelector {

public Population<DoubleGene, Double>
select(Population<DoubleGene, Double> population, int count) {
    // The incremental fitness probability array.
    final double[] incremental = incremental(probabilities(population));
    final Random random = new Random();

    return IntStream.range(0, count)
        // Select the individual index.
        .map(i -> indexOf(incremental, random.nextDouble()))
        // Select the individual.
        .mapToObj(i -> population.get(i))
        // Create the new population object.
        .collect(Population.toPopulation());
}

// Calculate the fitness probabilities of the given population.
static double[] probabilities(Population<?, Double> population) {
    final double[] fitness = population.stream()
        .mapToDouble(pt -> pt.getFitness())
        .toArray();
    final double sum = Arrays.stream(fitness).sum();

    return Arrays.stream(fitness)
        .map(v -> v/sum)
        .toArray();
}

// Create the incremental probability array.
static double[] incremental(final double[] values) {
    for (int i = 1; i < values.length; ++i) {
        values[i] += values[i - 1];
    }
    return values;
}

// Binary search for the individual index for a given probability.
static int indexOf(final double[] incr, final double v) {
    int imin = 0;
    int imax = incr.length;
    int index = -1;

    while (imax > imin && index == -1) {
        final int imid = (imin + imax) >>> 1;

        if (imid == 0 || (incr[imid] >= v && incr[imid - 1] < v)) {
            index = imid;
        } else if (incr[imid] <= v) {
            imin = imid + 1;
        } else if (incr[imid] > v) {
            imax = imid;
        }
    }

    return index;
}
}

代码已从＆＃39; RouletteWheelSelector＆＃39;中提取。 Jenetics项目。

用Java定义轮盘赌轮中的概率

2 个答案: