自私的基因_自私基因的生物计算机模拟

最新推荐文章于 2024-09-27 00:45:01 发布

danpu0978

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量293

点赞数

文章标签： java python 人工智能队列 cuda

原文链接：https://www.javacodegeeks.com/2015/04/biological-computer-simulation-of-selfish-genes.html

版权

自私的基因

TL; DR：我对猴子的行为进化进行了计算机模拟，继续阅读以了解最初在《自私的基因》中是如何陈述问题的。第一部分显示了我的Java实现，第二部分显示了图表结果和结论。

问题

我最近读了理查德·道金斯（ Richard Dawkins）的《自私的基因》，尽管已经40岁，但它的开篇非常开阔。尽管原始文本有时已经过时了（“ 您只能在头骨中装上几百个晶体管 ，但如今更像是数万亿 个晶体管 ，您好，摩尔定律），但一般的要求却像从前一样吸引人。

作为计算机工程师，引起我特别注意的一章是关于进行社交修饰的动物，例如某些猴子（请参见上图）。让我引用相关章节：

假设某个物种[…]被带有危险疾病的特别讨厌的壁虱所寄生。非常重要的一点是，应尽快清除这些壁虱。 […]一个人可能无法伸手可及，但没有什么比让朋友为他做容易的事了。以后，当朋友被自己寄生时，可以偿还善行。 […]这具有直接的直观意义。任何有意识的先见之明的人都可以看出，达成相互退让的安排是明智的。 […]

假设B在他的头顶上有一个寄生虫。一个把它拉下来。后来，时机到了，A头上有寄生虫。他自然地寻找B，以便B可以偿还他的善行。 B只是转过鼻子走开。 B是一个骗子，一个人接受其他人的利他主义的利益，但不偿还或无偿还。作弊要比不加选择的利他主义者做得更好，因为作弊者无需付出成本即可获得收益。可以肯定的是，与去除寄生虫的好处相比，修饰另一个人的头部的花费似乎很小，但这并不是可以忽略的。必须花费一些宝贵的精力和时间。

让总体由采用两种策略之一的个体组成。 […]称这两个策略为Sucker和Cheat。吸盘会随意修饰需要的任何人。骗子接受抽油机的利他主义，但他们从不修饰别人，甚至以前没有修饰过的人也没有。 […]作弊会比傻瓜做得更好。即使整个人口濒临灭绝，也永远不会有比傻瓜做得更好的人。因此，只要我们只考虑这两种策略，没有什么能阻止吸盘的灭绝，而且很可能阻止整个人口的灭绝。

但是现在，假设有第三种策略称为Grudger。怨恨者会为陌生人和以前曾修饰过他们的人提供服务。但是，如果任何人欺骗了他们，他们会记住事件并怀恨在心：他们将来不会修饰该人。在充满怨恨和吮吸者的人群中，不可能分辨出哪个是哪个。两种类型对其他所有人都有利他的表现[…]。如果与作弊者相比，仇恨者稀少，那么仇恨者基因将灭绝。一旦仇恨者设法增加数量，使他们达到关键的比例，他们彼此相遇的机会就变得足够大，可以抵消他们在欺骗作弊方面的浪费。当达到这个关键比例时，他们将开始平均获得比作弊更高的回报，并且作弊将以加速的速度被驱逐到灭绝。 […]

引自：理查德·道金斯（ Richard Dawkins）的《自私的基因》（ISBN 0-19-857519-X）。

随后，作者进行了一系列计算机模拟，以观察这三种策略在各种条件下如何共同发挥作用。显然源代码不可用，我对此很满意。首先，因为我有机会编写一些有趣的代码。其次：这本书出版于1976年，距C发明4年，距C ++多年（使您了解），我真的不太想Fortran 。

实作

因此，我砍掉了几节课来模拟整个人群中的作弊者，吮吸者和怨恨者。我想看看不同类型的行为如何影响人口规模。哪种行为稳定并保证生存。最后，如何减轻随机突变和死亡。我决定尝试一些技术，即：

手工进行依赖注入，没有任何容器
完全单线程
逻辑时钟已显式改进以模拟时间流逝

我们将模拟一群猴子（从几只到几百万只），每只猴子都有独立的行为，随机的寿命等等。使用诸如角色或至少线程之类的多代理解决方案似乎很明显。但是， “React式编程原理”课程告诉我这通常是一项过度设计。从本质上讲，这种模拟是一系列将来应该发生的事件：一只猴子应该在2年内出生，应该在5年内繁殖，并且应该在10年内死亡。当然，此类事件更多，猴子也更多。但是，将所有这些事件放入单个优先级队列中就足够了，在这些队列中，将来最接近的事件将排在第一位。这就是Planner的基本实现方式：

public abstract class Action implements Comparable<Action> {
 
    private final Instant schedule;
 
    public Action(Clock simulationTime, Duration delay) {
        this.schedule = simulationTime.instant().plus(delay);
    }
 
    @Override
    public int compareTo(Action other) {
        return this.schedule.compareTo(other.schedule);
    }
 
    public abstract void run();
 
}
 
//...
 
public class Planner implements Runnable {
 
    private final Queue<Action> pending = new PriorityQueue<>();
    private final SimulationClock simulationClock;
 
    public void schedule(Action action) {
        pending.add(action);
    }
 
    @Override
    public void run() {
        while (!pending.isEmpty()) {
            Action nearestAction = pending.poll();
            simulationClock.advanceTo(nearestAction.getSchedule());
            nearestAction.run();
        }
    }
}

我们有一个具有预定义schedule的Action （应在何时执行）和一个pending的将来操作队列。无需等待，我们只需选择将来的最近动作并提前模拟时间即可：

import java.time.Clock;
 
public class SimulationClock extends Clock {
 
    private Instant simulationNow = Instant.now();
 
    @Override
    public Instant instant() {
        return simulationNow;
    }
 
    public void advanceTo(Instant instant) {
        simulationNow = instant;
    }
 
}

因此，我们实质上实现了一个事件循环，可以在队列中的任何位置（不一定在末尾）添加事件。现在，当我们有了一个基本框架时，让我们实现猴子的行为：

public class Sucker extends Monkey {
    //...
 
    @Override
    public boolean acceptsToGroom(Monkey monkey) {
        return true;
    }
 
}
 
public class Cheater extends Monkey {
 
    private final double acceptProbability;
 
    //...
 
    @Override
    public boolean acceptsToGroom(Monkey monkey) {
        return Math.random() < acceptProbability;
    }
}
 
public class Grudger extends Monkey {
 
    private final Set<Monkey> cheaters = new HashSet<>();
 
    @Override
    public boolean acceptsToGroom(Monkey monkey) {
        return !cheaters.contains(monkey);
    }
 
    @Override
    public void monkeyRejectedToGroomMe(Monkey monkey) {
        cheaters.add(monkey);
    }
 
}

如您所见，这三个类捕获了三种不同的行为。 Sucker总是接受修饰请求， Cheater只是有时（在原始模拟中-从来没有，但是我使它可配置）， Grudger记得谁之前拒绝了他们的请求。猴子聚集在一个“ Population类中，这是一个小片段：

public class Population {
 
    private final Set<Monkey> monkeys = new HashSet<>();
    private final MonkeyFactory monkeyFactory;
 
    private Population addMonkey(Monkey child) {
        if (!full()) {
            newMonkey(child);
        }
        return this;
    }
 
    private boolean full() {
        return monkeys.size() >= environment.getMaxPopulationSize();
    }
 
    private void newMonkey(Monkey child) {
        monkeys.add(child);
        planner.scheduleMonkeyLifecycle(child, this);
        log.debug("New monkey in population {}total {}", child, monkeys.size());
    }
 
//...
}

我们为每只新猴子安排其所谓的生命周期，即与繁殖，修饰和死亡有关的事件（在Planner ）：

void scheduleMonkeyLifecycle(Monkey child, Population population) {
    askForGrooming(child, environment.getParasiteInfection().make(), population);
    scheduleBreedings(child, population);
    kill(child, environment.getLifetime().make(), population);
}
 
void askForGrooming(Monkey child, Duration parasiteInfection, Population population) {
    schedule(new AskForGrooming(child, parasiteInfection, population));
}
 
private void scheduleBreedings(Monkey child, Population population) {
    final int childrenCount = RANDOM.nextInt(environment.getMaxChildren() + 1);
    IntStream.
            rangeClosed(1, childrenCount)
            .forEach(x -> breed(child, environment.getBreeding().make(), population));
}
 
void kill(Monkey child, Duration lifetime, Population population) {
    schedule(new Kill(child, lifetime, population));
}
 
private void breed(Monkey child, Duration breeding, Population population) {
    schedule(new Breed(child, breeding, population));
}

AskForGrooming ， Kill ， Breed等是已经提到的Action类的实例，例如Kill ：

public class Kill extends MonkeyAction {
    private final Population population;
 
    public Kill(Monkey monkey, Duration lifetime, Population population) {
        super(monkey, lifetime);
        this.population = population;
    }
 
    @Override
    public void run(Monkey monkey) {
        population.kill(monkey);
    }
}

我将所有模拟参数封装在一个简单的值类Environment ，许多参数（例如parasiteInfection ， lifetime或breeding不是常量，而是RandomPeriod类的实例：

@Value
public class RandomPeriod {
 
    private static final Random RANDOM = new Random();
 
    Period expected;
    Period stdDev;
 
    public Duration make() {
        final long shift = Periods.toDuration(expected).toMillis();
        final long stdDev = Periods.toDuration(this.stdDev).toMillis();
        final double gaussian = RANDOM.nextGaussian() * stdDev;
        double randomMillis = shift + gaussian;
        return Duration.ofMillis((long) randomMillis);
    }
 
}

这使我能够捕捉具有期望值，标准偏差和正态分布的随机时间段的概念。 make()方法仅生成一个这样的随机周期。我不会探索该模拟的完整源代码，可以在GitHub上找到。现在终于可以运行几次了，观察种群如何增长（或灭绝）。顺便说一下，我使用相同的计划程序和操作机制来查看发生的情况：我只需每年一次（逻辑时间！）注入Probe动作，然后输出当前的人口规模。

就像许多事件循环一样，访问事件必须只有一个线程。我们遵循这种做法，模拟是单线程的，因此根本不需要执行任何同步或锁定，我们还可以使用标准，不安全但速度更快的集合。较少的上下文切换和改进的缓存局部性也有帮助。同样，我们可以轻松地将模拟状态转储到磁盘上，例如以后将其还原。当然有缺点。由于有成千上万的猴子，因此模拟速度变慢，除了谨慎的优化和购买更快的CPU（甚至没有更多的CPU！）外，我们无能为力。

本实验

作为对照组，我们从一个很小的（10个样本）种群开始，这些种群仅由吸盘以及吸盘和怨恨者的混合物组成。在没有作弊者的情况下，这两种行为是无法区分的。我们关闭突变（一个有傻瓜和怨恨的孩子成为骗子，而不是后来成为傻瓜或怨恨的孩子的可能性），然后查看种群的增长方式（X轴代表时间，Y轴代表种群数量）：

请注意，由于这两种行为的行为完全相同，因此吸盘和怨恨者的比例波动约50％。只用很少的作弊者进行模拟是没有意义的。由于他们通常不互相修饰，因此他们很快死去，擦除了“ 作弊基因 ”。另一方面，仅吸盘（无突变）呈指数增长（您可以清楚地看到高原后出生的新生代）：

但是，如果我们模拟一个只有100个骗子和5个骗子的种群，会发生什么情况？突变再次被关闭以保持仿真的干净：

有两种可能的情况：作弊者基因消失或扩散，导致种群灭绝。这有点自相矛盾-如果这个特定的基因获胜，整个人口（包括那个基因！）注定要失败。现在让我们模拟一些更有趣的东西。我们打开了5％的突变概率，并要求作弊者在10个案例中有9个进行修饰（因此，它们的行为有点像傻瓜）。我们从拥有5个吮吸者和5个怨恨者的健康人群开始：

您是否看到怨恨者如何Swift扩张，并且几乎总是数量超过吮吸者？这是因为在有时由于突变而导致作弊者出现的环境中，吮吸者更加脆弱。您是否注意到每当出现少量吸盘时，人口如何Swift减少？怨恨者也很脆弱：他们在欺骗新生的骗子之前不知道自己是谁。但是，他们不会像傻瓜那样重复此错误。这就是为什么吸盘总是松动的原因，但是由于它们在某种程度上受到仇恨者的保护，因此它们并未完全灭绝。仇恨者并不直接，而是通过不修饰来杀死作弊者，从而减少威胁。这就是不同行为的配合方式。那么为什么人口最终灭绝了呢？仔细查看图表的末尾，在某些时候，由于某种随机原因，吮吸者的人数超过了怨恨者-在当时没有作弊者的情况下，这种情况尤其可能发生。所以发生了什么事？由于突变，一些作弊者突然出现了，这个猴子社会注定要失败。

现在让我们研究另一个例子：一个已经生活着100个吸盘的成熟社会，没有观察到其他行为。当然由于突变，仇恨者和作弊者很快就出现了。大多数情况下，这种模拟很快就结束了，几代之后就结束了。作弊者出生的可能性与怨恨者的可能性相同，但是我们需要更多的怨恨者来保护吮吸者。因此人口死亡。但是我设法进行了几次模拟，而这些社会实际上幸存了一段时间：