遗传算法与深度学习实战（2）——生命模拟及其应用_康威生命游戏

0. 前言

生命模拟是进化计算的一个特定子集，模拟了自然界中所观察到的自然过程，例如粒子或鸟群的聚集方式。生命模拟只是用来探索和优化问题的模拟形式之一，还有很多其他形式的模拟，可以更好地建模各种过程，但它们都源于康威生命游戏 (Conway’s Game of Life)。在本节中，我们将介绍生命模拟的基本概念，并使用 Python 实现康威生命游戏。

1. 康威生命游戏

生命游戏是由约翰·霍顿·康威 (John Horton Conway) 于 1970 年开发的一种简单的细胞自动机；这个“游戏”被认为是计算机模拟的起源。虽然模拟的规则很简单，但它的确能够得到优雅的图案和表现形式。

1.1 康威生命游戏的规则

康威生命游戏之所以优雅，归结于用于模拟细胞生命的规则的简洁性。使用以下四个简单的规则模拟细胞的生命周期：

• 任何活细胞如果周围少于两个存活邻居，则会死亡(因为人口稀少)
• 任何活细胞如果周围有两个或三个存活邻居，则会存活到下一代
• 任何活细胞如果周围有多于三个存活邻居，则会死亡(因为人口过剩)
• 任何死细胞如果周围恰好有三个存活邻居，则会变成一个活细胞(因为繁殖)

1.2 实现康威生命游戏

使用 Python 实现康威生命游戏：

import glob
import io
import base64
from IPython.display import HTML
from IPython import display as ipythondisplay
import matplotlib.pyplot as plt

def show_video():
    mp4list = glob.glob('*.mp4')
    if len(mp4list) > 0:
        mp4 = mp4list[0]
        video = io.open(mp4, 'r+b').read()
        encoded = base64.b64encode(video)
        ipythondisplay.display(HTML(data='''<video alt="test" autoplay 
                    loop controls style="height: 400px;">
                    <source src="data:video/mp4;base64,{0}" type="video/mp4" />
                </video>'''.format(encoded.decode('ascii'))))
    else: 
        print("Could not find video")

import numpy as np
import tqdm.notebook as nb

def life(X, steps):
    """
     Conway's Game of Life.
     - X, matrix with the initial state of the game.
     - steps, number of generations.
    """
    def roll_it(x, y):
        # rolls the matrix X in a given direction
        return np.roll(np.roll(X, y, axis=0), x, axis=1)
    for _ in range(steps):
        # count the number of neighbours 
        Y = roll_it(1, 0) + roll_it(0, 1) + roll_it(-1, 0) \
            + roll_it(0, -1) + roll_it(1, 1) + roll_it(-1, -1) \
            + roll_it(1, -1) + roll_it(-1, 1)
        # game of life rules
        X = np.logical_or(np.logical_and(X, Y ==2), Y==3)
        X = X.astype(int)
        yield X

X = np.zeros((40, 40)) # 40 by 40 dead cells
# R-pentomino
X[23, 22:24] = 1
X[24, 21:23] = 1
X[25, 22] = 1
plt.imshow(X)
plt.show()

from matplotlib import pyplot as plt
import matplotlib.animation as manimation

FFMpegWriter = manimation.writers['ffmpeg']
metadata = dict(title='Game of life', artist='JustGlowing')
writer = FFMpegWriter(fps=10, metadata=metadata)
fig = plt.figure()
fig.patch.set_facecolor('black')
with writer.saving(fig, "game_of_life.mp4", 200):
    plt.spy(X)
    plt.axis('off')
    writer.grab_frame()
    plt.clf()
    for x in nb.tqdm(life(X, 800),total=800):
        plt.spy(x)
        plt.axis('off')
        writer.grab_frame()
        plt.clf()
show_video()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

运行程序，并观察输出，如下图所示。对于这个简单的生命模拟，起始细胞图案很简单，我们还可以使用其他的初始位置观察输出结果。

当模拟完成时，函数 show_video() 可以在输出中显示一个短视频片段。

在进程完成后播放视频，观看细胞模拟的运行。生命游戏的简洁和优雅展示了计算机模拟的强大威力，并由此诞生了多个学科。它展示了如何使用简单的规则来模拟生命，只要给定一些非常基本的规则和输入就能够生成新颖的的解决方案。虽然生命模拟逐渐发展的有别于康威生命游戏，但我们依然努力遵循康威生命游戏中宣扬的简单原则：利用一套简单的规则模拟一个复杂过程，目标是获取一些新颖的模式或解决方案。
在我们开始使用进化或其他方法推导更复杂的生命模拟之前，首先使用一个简单的实现来帮助我们理解。接下来，我们继续探索细胞生命的模拟，为简单起见，只考虑细胞属性，忽略物理条件。

1.3 空间生命和智能体模拟

使用空间表示的模拟，如生命游戏，可以用来进行多种建模和预测，例如交通建模、病毒传播。但在进化深度学习 (Evolutionary Deep Learning, EDL) 中模拟的运行并不是我们的重点，我们关注更多地是数学驱动的，意味着需要更多地关注分析向量或距离，而不是物理空间。

2. 实现生命模拟

接下来，我们将实现一个简单的细胞生命模拟，旨在演示一些基本概念的简单实例。

(1) 首先，导入所需库：

import random
import time
import matplotlib.pyplot as plt
1
2
3

(2) 编写函数用于创建一个新的细胞，并根据所需的后代数量生成一个细胞列表或集合：

def create_cell():
    return dict(health = random.randint(1, 100))

def birth(offspring):
    return [create_cell() for i in range(offspring)]

cells = birth(10)
print(cells)
# [{'health': 2}, {'health': 10}, {'health': 16}, {'health': 6}, {'health': 66}, {'health': 16}, {'health': 15}, {'health': 95}, {'health': 78}, {'health': 82}]
1
2
3
4
5
6
7
8
9

(3) 定义繁殖和死亡的代码/规则，与生命游戏不同，使用一个预定义的参数 RPRD_RATE 来定义新细胞产生的可能性；同样，代码还根据随机评估来检查细胞的死亡情况：

RPRD_RATE = 25
DEATH_RATE = 25
1
2

(4) 创建繁殖和死亡函数，设置基本的生命模拟函数：

def reproduce(cells):
    return [create_cell() for cell in cells if random.randint(1, 100) < RPRD_RATE]  

def death(cells):
    return [cell for cell in cells if random.randint(1, 100) > DEATH_RATE ]

def run_generation(cells):
    cells.extend(reproduce(cells))
    return death(cells)
1
2
3
4
5
6
7
8
9

(5) 接下来，执行模拟，目标是增加细胞种群：

generations = 10 #@param {type:"slider", min:1, max:25, step:1}
initial_offspring = 10 #@param {type:"slider", min:10, max:1000, step:1}
reproduction_rate = 50 #@param {type:"slider", min:1, max:100, step:1}
death_rate = 25 #@param {type:"slider", min:1, max:100, step:1}

RPRD_RATE = reproduction_rate
DEATH_RATE = death_rate
cells = birth(initial_offspring)

history = []
for i in range(generations):  
    cells = run_generation(cells)
    history.append(len(cells))
plt.plot(history)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

观察模拟的运行，如果繁殖和死亡率设置正确，种群将会增加。可以修改驱动模拟的参数，修改参数后再次运行以查看更新的模拟结果。

以上实例的目标只是建立一个简单的细胞模拟，并通过定义控制细胞繁殖和死亡的速率尝试令种群增长。这个模拟并无太多新颖之处，主要目的是为了易于理解和使用。现在我们已经了解了如何实现生命模拟，接下来我们将介绍生命模拟的具体应用。

3. 生命模拟应用

在本节中，我们重用上一小节中的简单实例，并增加执行对细胞上定义的属性的优化。对于大多数进化算法而言，最终的目标是优化过程、参数或结构。
在本节中，我们为每个细胞增加一个新参数 strength。我们的目标是优化整个种群的细胞的 strength 参数，strength 参数代表生物体中能够使其在环境中成功存活的特征，因此我们的目标是在整个种群中最大化参数 strength。
使用实时绘图库 LiveLossPlot 绘制机器学习 (Machine Learning, ML) /深度学习 ( Deep learning, DL) 模型的训练损失，LiveLossPlot 库用于实时可视化训练过程中的损失和指标，可以在训练模型时实时更新和显示损失和指标的变化，有助于直观地监控模型的训练进展，首先使用 pip 安装 LiveLossPlot 库。

pip install livelossplot
1

(1) 导入 PlotLosses 类以及其他所需库：

import random
import time
import matplotlib.pyplot as plt
from livelossplot import PlotLosses
1
2
3
4

(2) 修改定义生命模拟的函数代码，使用新的参数 strength 来推导细胞的健康状况：

RPRD_BOUNDS = 25
DEATH_BOUNDS = 25

def create_cell():
    return dict(
        health = random.randint(1, 100),
        strength = random.randint(1, 100)
        )                     

def birth(offspring):
    return [create_cell() for i in range(offspring)]

def evaluate(cells):
    for cell in cells:
        cell["health"] *= cell["strength"]/100 
    return cells
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

(3) 同样，修改繁殖和死亡函数，不再选择随机细胞进行繁殖或死亡。相反，新函数根据健康属性来确定细胞是否繁殖或死亡。新增两个参数，RPRD_BOUNDS 和 DEATH_BOUNDS 控制细胞在何种健康水平下可以繁殖或何时会死亡：

def reproduce(cells):
    return [create_cell() for cell in cells if cell["health"] > RPRD_BOUNDS]  

def death(cells):  
    return [cell for cell in cells if cell["health"] > DEATH_BOUNDS ]

def run_generation(cells):
    cells = evaluate(cells)
    cells.extend(reproduce(cells))
    return death(cells)
1
2
3
4
5
6
7
8
9
10

(4) 在以上代码中，根据细胞健康状况调整了明确的规则来确定细胞在何种情况下会死亡或繁殖。模拟的目标是优化细胞的种群属性，最后一个修改是在生成输出时使用 PlotLosses 类输出模拟的实时图形：

generations = 25 #@param {type:"slider", min:1, max:25, step:1}
initial_offspring = 10 #@param {type:"slider", min:10, max:1000, step:1}
reproduction_bounds = 50#@param {type:"slider", min:1, max:100, step:1}
death_bounds = 25 #@param {type:"slider", min:1, max:100, step:1}

RPRD_RATE = reproduction_bounds
DEATH_RATE = death_bounds
cells = birth(initial_offspring)

groups = {'Population': ['population'], 'Attributes' : ['avg_strength','avg_health']}
liveloss = PlotLosses(groups=groups)

history = {}
for i in range(generations):  
    cells = run_generation(cells)  
    history["population"] = len(cells)
    history["avg_strength"] = sum([cell["strength"] for cell in cells])/(len(cells)+1) 
    history["avg_health"] = sum([cell["health"] for cell in cells])/(len(cells)+1) 
    liveloss.update(history)
    liveloss.send() 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行代码，下图显示了运行25代模拟后的输出。可以看到，在左侧的属性图中，strength的平均值和健康状况都呈上升趋势。

通过修改生命模拟代码，我们能够进行单个属性的简单优化，虽然可以看到种群的 strength 和健康状况逐渐增加，但结果并不令人满意。实际上，如果仅仅使用上示生命模拟复制现实世界，那么世界可能永远无法进化成现在的样子。可以通过完成以下问题进一步理解上示生命模拟过程：

• 修改死亡率和出生率参数，观察运行结果
• 修改 evaluate 函数，改变返回的健康参数，然后重新运行模拟，观察其对运行结果的影响
• 修改 create_cell 函数中的 health 和 strength 的初始值后，运行模拟

模拟是一个多样化的领域，但我们主要关注利用模拟进化进行优化。
上示生命模拟缺失的关键是细胞传递其优秀特征给后代的能力。达尔文首次提出生物会将其优秀特征传递给后代，并称之为进化。事实证明，进化理论不仅是地球上生命的基础，也是进化计算的基础。

小结

生命游戏演示了基于规则的生命模拟的基本形式，生命模拟可以帮助我们优化计算和模拟实际问题。生命模拟可通过使用函数定义繁殖和死亡来观察简单行为。本节中，我们介绍了生命模拟的基本概念及其应用。

系列链接

遗传算法与深度学习实战（1）——进化深度学习
遗传算法与深度学习实战（3）——生命模拟与进化论
遗传算法与深度学习实战（4）——遗传算法详解与实现
遗传算法与深度学习实战（5）——遗传算法框架DEAP