算法 on 苏三有春的博客

Q-learning强化算法详解

Mon, 20 Jan 2025 13:20:00 +0800

前言

Hi,everyone，相信现在看到这篇文章的程序员或者未来的程序员们，或多或少在曾经某个懵懂的青春岁月里都想过“我以后要做一款属于自己的游戏！”这样美好的念头。当然，时过境迁，有的忘记了曾经的誓言，有的当一个笑话，不管怎么说，今天我们来聊聊，但不是说我们要开始制作出LOL那样的MOBA类游戏，也不是CS那样的FPS游戏，甚至不是一款游戏，而是游戏的一部分——游戏AI。

当然，游戏AI也有多种多样的，有与人进行博弈的，有伪装成玩家的解决游戏问题的，甚至，在大语言模型盛行的今天，也有进行文字情感交流的。但归根结底，笔者认为它们都有一些共通点：

能够获取环境输入
能够识别并处理环境
输出一个行为
行为改变环境并获得一些反馈

如三国志（顺便一提，笔者非常喜欢玩三国志13和14），总而言之呢，我们的目标，就是设计一个智能体，它能获得环境（游戏内的场景战况等whatever）的输入，能处理环境，并输出一个行为（上下左右跳跑等whatever），这个行为会导致环境发生变化，环境的变化会给予智能体一个反馈，让它能够计算自己距离目标（广义上的距离，不一定是位置的移动，也可能是击中数击杀数最终胜利等whatever），来判断和抉择下一步行为。

要设计这样一个智能体，我们理所当然地想到强化学习，至此引出本文的第一个重点概念：什么是强化学习。

本文将近万字，制作不易，请各位读者老爷不吝赏一个赞吧！这对我来说真的很重要，感谢感谢！

强化学习

什么是强化学习

强化学习方法起源于动物心理学的相关原理，模仿人类和动物学习的试错机制，是通过与环境交互，学习状态到行为的映射关系，以获得最大累计期望回报的方法。状态到行为的映射关系也即策略，表示在各个状态下，智能体采取的行为或行为概率。

强化学习就像是人类的学习，本质上是通过与环境交互进行学习，智能体会从与环境交互的过程中获得反馈，可能是正反馈也可能是负反馈，这种反馈经验刺激智能体去拟合出一条奖励更多或者损失更小的路线。从交互中学习就是强化学习的理论基础概念。

强化学习是通过智能体与环境的交互，学习状态到行为之间的映射关系，因此，它包括智能体和环境两大对象。同时，还需要注意的是，强化学习是与时间序列有关的。

智能体

智能体，指的是要完成某项任务的对象，强化学习的最终目的，是让智能体通过大量的学习，能够在环境中完成某个目的。在一个离散的时间序列t=0,1,2….中，智能体会在每一个时间$t_n$内，从环境中接收一个状态$s_t$和回报$r_t$，并通过$r_t$和当前自身所处的状态$s_t$，以及已产生的经验教训判断，产生下一步$a_{t+1}$，以期望获得最大的回报。

环境

环境，指的是智能体所处的环境环境范围，其包含智能体可变更的状态集合以及每一种状态所获得的回报，例如：环境可以是一个二维的4*4地图，其中包含了智能体可以行进的16个位置以及每个位置对应的智能体到达该位置时可获得的回报。在离散的时间序列t=0,1,2,…中，智能体会在每个时间$t_n$内进行相应的行为$a_t$，该行为会使智能体的环境发生改变（也可能不会发生改变），环境会向智能体反馈当前的状态$s_t$和回报$r_t$。

强化学习原理

智能体不会被告知其在当前状态下，下一步行为应当采取何种行为，只能通过不断地尝试每一种动作，并收集环境中给予的反馈，来改善自己的行为，其改善行为的本质，就是追求回报最大化或损失最小化，在经过不断地尝试（多次迭代）后，智能体的行为会收敛成某个路径，即学习到最优的行为方式。

当然，这仅是笼统的强化学习原理，智能体作为一个学习行为的对象，其不一定只能通过试完每一步行为才能收敛，开发者可以通过一些算法，来加速最优行为的收敛。

Q-learning

Q-learning 是一种强化学习算法，其核心是一个叫Q表的表格Q(state, action)，这个表格一轴表示state（状态），一轴表示action（行为），Q(i,j) = k就表示智能体在 i 这个状态下，如果采取 j 这个行为会带来奖励 k ，Q表示Q-learning算法的核心，用来记录不同状态下不同行为的收益，随着迭代次数的增加，Q函数会被拟合得越来越好直至收敛或者达到指定的迭代次数。

下面笔者将分别介绍智能体与环境两个对象，并以gym库提供的模拟游戏环境FrozenLake为例，实现Q-learning算法，训练一个智能体。

Q-learning智能体

我们知道，Q-learning算法是一种强化学习算法，强化学习有智能体与环境两个对象，本小节我们就来介绍Q-learning智能体。

Q-learning智能体自身主要是有两个主要动作：选择行为，更新Q表。

选择行为：指的是智能体在接收外部给予的信息后，选择下一步行动的过程，其中，智能体需判断是否进行探索？如果不探索，该以何种方式来选择行为？
更新Q表：在选择行为后，智能体会从外部环境接收信息，然后根据外部环境提供的回报，状态等信息来更新Q表。更新Q表的函数笔者会在后面给出并详细解释。

参数解释

Q-learning智能体自身维护了一个Q表，在初始化Q-learning时会初始化自身的Q表，与此同时，智能体还需输入几个参数：学习率、折扣因子（奖励衰减）、贪婪度。

在解释上面几个参数之前，我们要先给出几个词的定义，以避免在解释参数时产生误解：

回报：回报指的是环境给予智能体的反馈，是外部输入，比如：掉进冰湖为-1，到达终点为1，正常路径为0等，当智能体处于某一状态时，，就算它在原地打转或再次回到此处，它所获得的回报是相同的。
奖励：奖励指的是智能体自身Q表中的记录，是内部变化，记录其在s状态，a行为下的奖励，Q表的值可能会随着智能体不断地运动，时间不断地推移而发生改变，即Q表更新，在下文中我们会给出Q表更新函数。智能体的每一次行动，都会产生一次Q表更新。Q表的值是动态的，会改变的，随着迭代次数增加，慢慢会出现，某些状态下的某些行为会更具奖励，促使智能体去更愿意尝试那样的行为，这就是“收敛”。读者也可以将奖励理解为经验。
探索：探索指的是当智能体进行贪婪策略时，会跳出原定的行为策略，尝试随机地探索其它区域，适当的探索有利于使智能体尝试新的未知的状态，而不束缚于“经验主义”。

OK，当你理解这几个词的意思后，我们现在开始解释参数：

学习率：学习率这个参数是各大机器学习算法的常客，在这里表示智能体对所获得的经验的学习程度，一般在属于[0,1]，学习率越大，会使得智能体跨的步伐越大，使之收敛速度越快，但注意，步伐越大可能存在的误差越大，导致无法正确收敛（陷入局部最优），损失会震荡甚至变大。反之，学习率越小，步伐越小，收敛的速度越慢。学习率是一个超参数，即由程序员事先拟定，在整个迭代过程中不可更改。
折扣因子：折扣因子也叫奖励衰减，是对未来奖励的衰减值，当衰减值为0时，则代表智能体近视，看不见下一状态的最优行为，即智能体只在乎当前状态下环境给出的回报，而不在乎下一状态的奖励。换而言之，智能体只在乎眼下能获得的回报。当衰减值为1时，代表智能体带了眼镜，能够看得更远，它完完整整地看清楚了下一步自己会获得多大的奖励，而不仅仅只看见眼前的回报。
贪婪度：贪婪度表示智能体尝试其它行为的可能性，如果贪婪度为0，则说明智能体只会考虑已有的奖励来选择行为，而贪婪度越高，则智能体越有可能随机选择一个行为（探索），而不是根据奖励来选择，为什么贪婪度是必要的呢，是为了避免智能体陷入局部最优解而无法收敛，随机的动作可以让智能体有机会跳出局部最优解，但务必把握好平衡，太过贪婪也可能导致智能体的行为混乱而无法收敛。

下面给出智能体的初始化方法：

1
2
3
4
5
6
7
8
9


 # 初始化，参数：状态数，动作数，学习率，折扣因子（奖励衰减），贪婪度
 def __init__(self, n_states, n_actions, learning_rate=0.1, gamma=0.99, epsilon=0.1):
 self.q_table = np.zeros((n_states, n_actions)) #初始化Q表，Q表的初始化为0，也可以初始化为随机值
 self.learning_rate = learning_rate #初始化学习率，学习率默认为0.1
 self.discount_factor = gamma #初始化折扣因子，折扣因子默认为0.99
 self.epsilon = epsilon #初始化贪婪度，贪婪度默认为0.1
 # 打印初始化Q表
 print("initial q_table:")
 print(self.q_table)

由于笔者的模拟环境为gym库提供的ForzenLake，这里的n_states是冰湖的地图大小，即4 * 4 = 16个格子，行为数为4，分别是向左，向下，向右，向上移动。

行为选择

现在我们来看一看智能体是如何选择自己的行为的，智能体的行为选择策略原理非常简单，大伙简单看看，理解就行。

当智能体到达某一状态（位置）时，首先会开始选择行为，即接下来我该往哪个方向走。但在动脚起身之前，我们先要抛一个硬币，诶，就是贪婪度，在上面的初始化过程中，我们将贪婪度设置为0.1，即我们获取一个随机数，当数小于0.1时，则采取探索策略，当数大于0.1时，我们按照正常的策略前进，毕竟人不能太贪婪嘛（智能体也是）。

最简单的贪婪策略就是随机，即随机选择一个行为，根本不在乎Q表上记录了哪一行为奖励最高（就是任性！）。当然你也可以选择其它的贪婪策略，根据自己的需要选择，但切记，贪婪的目的是为了让智能体尝试采取其它行为，不束缚于“经验主义”，陷入局部最优解之中。试想以一下，当智能体来到一个岔路口，它曾经走过向左的方向，也确实从左方能够到达终点获得相应的回报，但从上帝视角来看，往右走会有一条更近的路抵达终点，但是由于智能体没去过，且贪婪度为0，那么它将“永远”不会尝试这条路。

正常策略即通过Q表，来选择最优行为了，因为智能体会根据环境的反馈以及Q表更新函数，来记录哪一个行为它曾经试过且“最好”，因此，它会选择那个最优的行为，也就是上面那个例子中的“向左走”，因为它曾经确实走通过这条路，并拿到过不错的回报。

我们在这里并没有说贪婪策略就一定好，或者正常策略就一定好，两种策略是互补的关系，就像现实社会中，总要有人在已探明的道路上巩固地基，也要有人跃跃欲试去探索未知的道路，关键在于开发智能体的你，是否能够平衡两者。

下面给出行为选择的方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


 # 选择动作，参数：状态
 def choose_action(self, state):
 # 判断贪婪度
 if np.random.uniform(0, 1) < self.epsilon:
 # 如果进入了贪婪状态，那么agent将会尝试随机选择一个动作，此步称之为【探索】
 return np.random.choice(self.q_table.shape[1])
 else:
 # 选择最优动作，即在Q表中该状态下最大的Q值，此步称之为【利用】 
 state_all = self.q_table[state, :]
 # 根据Q值最大原则选取action，如果有多个action的Q相同且最大，则随机选取一个
 max_indices = np.argwhere(state_all == np.max(state_all)).flatten()
 return np.random.choice(max_indices)

Q表更新

终于到Q表更新了，这个更新是Q-learning算法的一大难点，也牵扯到上面的两大参数学习率与折扣因子，因此我们必须好好聊聊这个函数：

$$ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha[R_{t+1} + \gamma max_{a'}(s_{t+1},a') - Q(s_t,a_t)] $$

$Q(s_t,a_t)$：指的是Q表中，当前状态$s_t$，行为$a_t$时的奖励
$\alpha$：指的是学习率
$R_{t+1}$：指的是下一个状态$S_{t+1}$下，环境给予智能体的回报
$\gamma$：指的是折扣因子，也叫奖励衰减
$max_{a’}(s_{t+1},a’)$：指的是奖励，实际上是一个Q表中的值，该值是下一个状态$s_{t+1}$的所有行为$a_0,a_1,a_2,…$中，最大的一个。

Q表更新函数与上面的参数结合起来看，有助于你理解什么是步伐，什么是奖励，什么是回报，请允许我不厌其烦再唠叨一遍：

$Q(s_t,a_t)$：是当前状态，当前行为的奖励
$max_{a’}(s_{t+1},a’)$：是下一步状态，所有行为中的最大奖励。
$R_{t+1}$：下一步状态的回报
$R_{t+1} + \gamma max_{a’}(s_{t+1},a’) - Q(s_t,a_t)$：步伐，即此次Q表需要更新的幅度

Q表更新的难理解处：

笔者一开始没有搞清楚Q表的更新逻辑，这条Q表更新函数中的$max_{a’}(s_{t+1},{a’})$究竟怎么计算的，其实当我们知道了什么时候开始更新Q表时，这个Q表更新函数就可以看得懂了：

在经过 t 时间后，智能体来到了位置（状态）$s_t$处，此时，智能体会先选择下一个行为，但请注意，此时智能体还未动身前往下一个位置
通过环境反馈，智能体要获取当采取某一行为后，判断出下一位置的状态$s_{t+1}$，以及可获得的回报$R_{t+1}$，但请注意，此时智能体还停留在$s_t$处，也就是智能体先不更新自己的位置，而是先从$s_{t+1}$处获取相应的信息更新Q表。
更新Q表
智能体动身前往下一位置（状态）

因此，我们可知$max_{a’}(s_{t+1},a’)$表示的是，智能体在选择下一步行为后得到的下一步状态，那个状态下的最优行为。总而言之，智能体的奖励逻辑是，根据下一状态中4个动作中的最大奖励值，来计算出当前的这个状态所执行的这个动作的奖励值，这样的计算方式避免智能体只看当前状态的回报，也要根据“历史经验”适当考虑未来的收益。如果当前状态的回报丰厚，但是根据Q表的记录，未来下一步的奖励并不理想，也会拉低智能体对当前这一状态的“印象”。使之不会在Q表中给予很高的分数。

这里可能有些同学觉得过于啰嗦，但这是笔者踩过坑且困惑的地方，为了避免其它小伙伴也对此函数产生困惑，笔者还是要尽量解释一番。

我们来看下面这个例子，先看Frozen Lake的4*4地图：

在这个地图中，智能体出发点为左上角的格子，即第1行第1列处，此处对应Q表的第1行。终点在右下角的格子，即第4行第4列处，此处对应Q表的第16行。Q表将4*4的地图划为一个16个数据的一维数组。每个格子表示一个状态，所以我们可以说：状态即智能体所在的位置。在每个状态中，智能体可以执行4个操作，即：向左，向下，向右，向上移动，移动后，智能体会获得相应的奖励，如下所示：

在上述Q表中可以看到，第16行，即最下方的[0,0,0,0]，是终点，到了此处，显然就不需要再移动了，因此此处的向左，向下，向右，向上移动的奖励值都为0。

我们以第15行的数据来举例说明，第15行的数据为[0, -1, 0.8, 0]，此处是第4行，第3列的位置，即Forzen Lake地图中终点左边的格子。因此可以看到，在这个格子中，如果智能体向右走一步，即可达到终点，因此当智能体在这个状态下尝试向右走，那么根据Q表的更新运算规则：

$$ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha[R_{t+1} + \gamma max_{a'}(s_{t+1},a') - Q(s_t,a_t)] $$

显然，从初始化开始时，智能体是没有在这个位置（状态）下向右（行为）行走过的，在茫茫多次选择后，某一次，智能体恰好来到这个位置（状态），它打算向右（行为）行走试试。确定要向右走后，它开始计算自己想向右走的这一个行为会获得多少奖励。

我们开始算一下：

在此时，$Q(s_t,a_t)$为0，因为自初始化伊始，智能体还没有达到过终点，而我们定下的规则，只有达到终点，才有一个奖励“1”，其它的状态都没有奖励“0”。因此还没有尝试过在此处向右走的智能体原本的该状态该动作奖励值为0。

学习率$\alpha$我们定为0.8。

智能体很惊喜地发现，下一步就是终点，因此下一步可获得的奖励$R_{t+1}$为1。

奖励衰减因子$\gamma$我们定为0.99。

因为下一个状态就是终点，此前智能体从未到达，即使到达，它也无需在此处做多余的动作，也无需再走下一状态，因此下一个状态的所有动作的奖励值都为0，因此$max_{a’}(s_{t+1},a’)$为0。

我们可以得到算式：$Q(s_t,a_t) = 0 + 0.8\times(1 + 0.99\times0 - 0)=0.8$

回头再看看Q表，是不是发现，在第15行的第3个元素的数据为0.8。没错，这个Q表就是在智能体第一次访问终点时得到的Q表。

你可能会感到奇怪，为什么明明智能体已经到达了终点，为什么这一趟旅程仅仅只是让Q表更新了一个有用的元素。

对，第一次到达终点，仅仅会让智能体的上一个状态的动作获得奖励，而非整条路线都获得奖励。但我们从宏观上来看，原本仅仅在终点才有1的奖励值，现在在终点旁的一个位置$S_{t-1}$，也有0.8的奖励值了，这多出来的具有正向奖励值的点会有什么作用呢？

如果我们把整个地图看作是一个海洋，终点是密度最大的地方，在一开始，除终点外，每个地方的密度都是一样的，智能体不知道该往哪个地方移动，只能随机尝试，只有当智能体非常靠近密度最大的终点时，智能体才会意识到，旁边有个疑似终点的地方。而当智能体到达终点$S_{t}$一次后，它会尝试记录下之前的动作，但肯定不是整条路线都记下来（指不定它绕了几次弯，走了几次胡同），因此它只记录最后一个步骤。怎么记录呢，就改变最后一个步骤的地区$S_{t-1}$的密度，当然不能改成和终点一样，那么下次就无法分辨哪个是终点了。因此，现在又多了一个地方的密度变大了，智能体下一次从起始点触发，就有更大的概率碰到密度不一样的地方，当重新来到$S_{t-1}$时那智能体就知道了，这个地方它留下过痕迹，那它就更愿意往这个地方走，同时嘞，它会重复上面的操作，基于这个地方，改变上一个地区$S_{t-2}$的密度，然后再检查这个地区$S_{t-1}$，当它开始检查这个地方$S_{t-1}$，嘿，您猜怎么着，它又发现了一个密度更大的地方（终点$S_{t}$）。这样，基于终点，慢慢地往外其它地方的密度都发生了变化，发生变化是基于曾经智能体来过这个区域，且它曾成功地通过该区域进入过终点的。

慢慢地，智能体进入终点$S_{t}$的次数越来越多，修改$S_{t-1}$的次数也越来越多，$S_{t-1}$的密度慢慢变得越来越大，也越来越接近终点$S_{t}$的密度了，同时呢，可能$S_{t-2}$与$S_{t-3}$都可以进入$S_{t-1}$，但如果$S_{t-2}$比$S_{t-3}$更容易进入$S_{t-1}$：（$P(S_{t-2}|S_{t-1})>P(S_{t-3}|S_{t-1})$），那么$S_{t-2}$密度上升的速度就会比$S_{t-3}$快，对于智能体来说，这个$S_{t-2}$比$S_{t-3}$更像终点（或者更接近终点），因此形成一个正反馈，越来越多地走$S_{t-2}$ →$S_{t-1}$→$S_{t}$这条路线。

一个离终点两格远，但距离$S_{t-1}$仅一格远的位置$S_{t-2}$的密度，也慢慢接近$s_{t-1}$且比$s_{t-3}$的密度更大。慢慢地，随着迭代次数的增加，在海洋中，就出现了一条密度明显高于其它地方的路径，就算智能体重新回到起点，它也能根据这一条路径快速走到终点，而不必像一开始时乱走一通。这样我们就称之为收敛了，也就是训练完成。

小结，Q表就是智能体的小本本，它在不断地试错中，渐渐摸索出了自己的行为方式，在$s_0$时采取$a_{i0}$的方式最好，在$s_1$时采取$a_{i1}$的行为最好等等……它小本本中的奖励，是从终点（有回报点）不断向外延伸的，而非到达终点后，此次到达终点所经历的所有点，采取的所有行为都会获得奖励。其次，大家要理解Q表的更新函数，这是Q-learning算法在重要的环节之一，更新函数所考虑的不仅仅是当前状态下的回报，也不好高骛远，只看未来不看当下，如何平衡奖励衰减与学习率，就要靠大家慢慢摸索了。

下面给出更新Q表的方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


 # 更新Q表，参数：状态，动作，奖励，下一个状态，是否结束
 def update(self, state, action, reward, next_state, done):
 #下面4行代码就是Q表的更新函数
 best_next_action = np.argmax(self.q_table[next_state])
 td_target = reward + self.discount_factor * self.q_table[next_state][best_next_action]
 td_error = td_target - self.q_table[state][action]
 self.q_table[state][action] += self.learning_rate * td_error
##################### 手动修改Q值，加快收敛速度，这里看似“作弊”，但是不影响Q-learning的原理 ############
 # if state == next_state:
 # self.q_table[state][action] = -1
 # if done:
 # if reward == 0:
 # self.q_table[state][action] = -1
###################### 当开启手动修改Q值时，会加速迭代的速度，但会影响学习曲线 #########################

ForzenLake模拟环境

gym库是由OpenAI推出的一个强化学习实验环境库，FrozenLake就是其库下的一个游戏模拟环境，简单介绍一下游戏规则：

环境设定为游戏角色在结冰的湖面中前进，寻找宝箱，但在冰湖中存在着一些洞，一旦掉入冰洞则失败，游戏结束，找到宝箱则成功，游戏结束。

以一个4*4的小冰湖地图为例：

显然，在这个冰湖中，角色初始位置在左上角的位置，从二维数组上的角度来看就是[0,0]，从一维数组的角度来看就是[0]，宝藏在地图右下角，从二维数组的角度上来看就是[3,3]，从一位数组的角度上来看就是[15]，注意：上面的地图仅仅是我们人类观察者所见到的地图，而智能体看到的并不是这样的地图，它仅能够知道自己走到了第几个格子或者第几行第几列的格子，并从中获得什么回报，因此笔者才强调从数组的角度出发，因为这是智能体的角度。

其次，作为上帝视角的我们，可以再冰湖上增加一些特殊的机制，比如湖面可能打滑，有概率往随机的方向上行动而不遵循智能体的意志，但仅仅是示例，咱们就不做那些复杂的操作了。

现在我们给出了环境的地图，接下来给出环境的回报规则：

只有在角色找到宝藏时，才会获得回报1，掉进冰洞与冰面行走回报都为0，掉进冰洞直接结束游戏，开启下一轮迭代。

by the way，因为掉进冰洞和在冰面行走的回报都为0，因此智能体是分不清掉进冰洞与冰面行走的区别，因此如果你想加速迭代，让智能体明白掉进冰洞是危险的，可以将掉进冰洞的回报设置为-1，让智能体意识到这里有惩罚，下一次迭代的策略就会避开这个位置。（这也是上面更新Q表代码中我们做的一点小小的“作弊”）。

接下来我们给出环境的代码：

 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


def run_episode(env, agent):
 state, info = env.reset() #重置环境，即更新角色状态（位置）
 #print(state)
 total_reward = 0
 done = False

 while not done: #判断游戏是否结束
 action = agent.choose_action(state) #智能体选择接下来的行为
 #print(env.step(action))
 next_state, reward, done, _, _ = env.step(action) #将行为输入给环境，环境会根据行为反馈下一步状态，回报，是否结束游戏等信息
 agent.update(state, action, reward, next_state, done) #根据环境反馈的信息以及自身的位置，智能体更新Q表 
 state = next_state #更新智能体的状态
 total_reward += reward #将当前回报加总，在整个一轮游戏结束后，看看此轮游戏获得的总回报，判断此轮游戏的收敛效果。

 return total_reward # 游戏结束后，返回本轮游戏的总回报值，可用于后续的曲线绘制和分析研究

# 使用示例
env = gym.make('FrozenLake-v1', desc=None, map_name="4x4", is_slippery=False, render_mode = "human") #创建冰湖环境，呈现画面
# env = gym.make('FrozenLake-v1', desc=None, map_name="4x4", is_slippery=False, render_mode = "ansi")
# env = gym.make('FrozenLake-v1', desc=None, map_name="4x4", is_slippery=False)
agent = QLearningAgent(env.observation_space.n, env.action_space.n) #初始化智能体
n_episodes = 10000 #迭代次数
rewards = [] #用来记录回报曲线，展示收敛效果

for episode in range(n_episodes):
 reward = run_episode(env, agent) #每一次run_episode，都是一次游戏进程，只有当游戏结束（掉进冰湖或拿到宝箱），才会返回
 rewards.append(reward) #将本轮游戏的总体回报记录下来，以便后续绘制曲线，展示收敛效果

在上面的代码中，我们完成了整个模拟环境的搭建以及迭代过程，基本上在每一行代码中都添加了注释，下面就不过多赘述了。reward列表和total_reward是非必要的选择，但会给我们后续研究智能体的迭代速度提供直观的数据支持，如果读者们要调参，修改策略等进阶玩法，则这一步是很重要的，当然读者们不一定只看回报这一个指标，你也可以将其它指标也收集起来，比如每一轮游戏的Q表等等，通过以下代码可以将每轮游戏的最终Q表打印出来：

1
2
3


# 打印最终的Q表
print("final q_table:")
print(agent.q_table)

最后，我们来解释一下gym.make方法的各种参数：

FrozenLakeLake：说明我们需要创建的模拟环境为冰湖
desc：作用是自定义网格地图布局，我们设置为None，即使用默认的预定义地图，如果需要自定义地图，可以传入一个字符串列表，如：[“SFFF”, “FHFH”, “FFFH”, “HFFG”]，其中：S表示起点，F表示安全冰面，H表示冰洞，G表示目标
map_name：选择预定的网格地图，当desc为None时生效，表明采用预定的4*4大小的地图
is_slippery：控制移动的随机性，True（默认），智能体执行动作时有1/3概率打滑，False则执行动作是确定的（智能体严格按照指定方向移动）
render_mode：设置环境渲染模式，human在屏幕上实时显示图形化界面，ansi在终端输出文本网格，None不渲染（默认）

总结

上面，咱们完整地讲解了Q-learning算法的基本原理，智能体与环境如何实现，有什么难点和需要掌握的地方，总的来说，Q-learning的本质核心其实也就是强化学习的本质核心——试错！只有在不断地跌倒和捶打中，才能诞生强大的智能体！抓住这一核心，其余的部分都可以做优化和修改，包括最关键的Q表更新函数，只要能够让智能体进化以达到自身目的，将其改的面目全非甚至不是Q-learning了又何尝不可呢，笔者只是通过Q-learning来初步学习强化学习，而强化学习并非只有Q-learning。笔者也把当初自己在学习过程中遇到的难点给详细阐述了一遍，当然笔者的语言功底有限，或许有部分还未讲清楚，也欢迎各位大佬留言。当笔者进一步学习其它强化学习知识点和算法的时候，再出文章，那么，下篇文章再见啦，祝各位变得更强！

完整代码

这代码笔者参考了下面参考文章的代码，浅浅修改了一些地方，并添加了一些注释，仅供参考：

 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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


import gym
import numpy as np
import matplotlib.pyplot as plt

class QLearningAgent:
 # 初始化，参数：状态数，动作数，学习率，折扣因子（奖励衰减），贪婪度
 def __init__(self, n_states, n_actions, learning_rate=0.1, gamma=0.99, epsilon=0.1):
 self.q_table = np.zeros((n_states, n_actions)) #初始化Q表，Q表的初始化为0，也可以初始化为随机值
 self.learning_rate = learning_rate #初始化学习率，学习率默认为0.1
 self.discount_factor = gamma #初始化折扣因子，折扣因子默认为0.99
 self.epsilon = epsilon #初始化贪婪度，贪婪度默认为0.1
 # 打印初始化Q表
 print("initial q_table:")
 print(self.q_table)


 # 选择动作，参数：状态
 def choose_action(self, state):
 # 判断贪婪度
 if np.random.uniform(0, 1) < self.epsilon:
 # 如果进入了贪婪状态，那么agent将会尝试随机选择一个动作，此步称之为【探索】
 return np.random.choice(self.q_table.shape[1])
 else:
 # 选择最优动作，即在Q表中该状态下最大的Q值，此步称之为【利用】
 # return np.argmax(self.q_table[state])
 # 根据Q值最大原则选取action，如果有多个action的Q相同且最大，则随机选取一个
 state_all = self.q_table[state, :]
 max_indices = np.argwhere(state_all == np.max(state_all)).flatten()
 return np.random.choice(max_indices)


 # 更新Q表，参数：状态，动作，奖励，下一个状态，是否结束
 def update(self, state, action, reward, next_state, done):
 best_next_action = np.argmax(self.q_table[next_state])
 td_target = reward + self.discount_factor * self.q_table[next_state][best_next_action]
 td_error = td_target - self.q_table[state][action]
 self.q_table[state][action] += self.learning_rate * td_error
##################### 手动修改Q值，加快收敛速度，这里看似“作弊”，但是不影响Q-learning的原理 ############
 # if state == next_state:
 # self.q_table[state][action] = -1
 # if done:
 # if reward == 0:
 # self.q_table[state][action] = -1
###################### 当开启手动修改Q值时，会加速迭代的速度，但会影响学习曲线 #########################

def run_episode(env, agent):
 state, info = env.reset() #重置环境，即更新角色状态（位置）
 #print(state)
 total_reward = 0
 done = False

 while not done: #判断游戏是否结束
 action = agent.choose_action(state) #智能体选择接下来的行为
 #print(env.step(action))
 next_state, reward, done, _, _ = env.step(action) #将行为输入给环境，环境会根据行为反馈下一步状态，回报，是否结束游戏等信息
 agent.update(state, action, reward, next_state, done) #根据环境反馈的信息以及自身的位置，智能体更新Q表 
 state = next_state #更新智能体的状态
 total_reward += reward #将当前回报加总，在整个一轮游戏结束后，看看此轮游戏获得的总回报，判断此轮游戏的收敛效果。

 return total_reward # 游戏结束后，返回本轮游戏的总回报值，可用于后续的曲线绘制和分析研究

# 使用示例
env = gym.make('FrozenLake-v1', desc=None, map_name="4x4", is_slippery=False, render_mode = "human") #创建冰湖环境，呈现画面
# env = gym.make('FrozenLake-v1', desc=None, map_name="4x4", is_slippery=False, render_mode = "ansi")
# env = gym.make('FrozenLake-v1', desc=None, map_name="4x4", is_slippery=False)
agent = QLearningAgent(env.observation_space.n, env.action_space.n) #初始化智能体
n_episodes = 10000 #迭代次数
rewards = [] #用来记录回报曲线，展示收敛效果

for episode in range(n_episodes): #每一次run_episode，都是一次游戏进程，只有当游戏结束（掉进冰湖或拿到宝箱），才会返回
 reward = run_episode(env, agent) #将本轮游戏的总体回报记录下来，以便后续绘制曲线，展示收敛效果
 rewards.append(reward)

# 打印最终的Q表
print("final q_table:")
print(agent.q_table)

# 绘制学习曲线
plt.plot(np.cumsum(rewards) / (np.arange(n_episodes) + 1))
plt.xlabel('Episode')
plt.ylabel('Average Reward')
plt.title('Q-Learning on FrozenLake')
plt.show()

# 测试学习到的策略
n_test_episodes = 100
test_rewards = []

for _ in range(n_test_episodes):
 state, info = env.reset()
 total_reward = 0
 done = False
 while not done:
 action = np.argmax(agent.q_table[state])
 state, reward, done, _, _ = env.step(action)
 total_reward += reward
 test_rewards.append(total_reward)

print(f"Average test reward: {np.mean(test_rewards)}")

参考文章

智能体入门——遗传算法与Qlearning_genetic algorithm和qlearning的区别和关系-CSDN博客

【强化学习】Q-Learning算法详解-CSDN博客

【机器学习】Q-Learning详细介绍-CSDN博客

强化学习之迷宫Q-Learning实践笔记——入门篇 - 知乎

遗传算法

Sat, 21 Dec 2024 13:20:00 +0800

前言

遗传算法是数学建模中非常重要的一种搜索和优化算法，掌握遗传算法的精髓除了在竞赛中具有优势以外，更主要的是在解决实际问题的时候提供了一种全新的思路，通过将现实中的某种模式转换成算法，并用以解决某种问题的这种思路，或许是算法创新，提高效率的另一条路。

本文将会介绍遗传算法的思想，优缺点以及提供一个遗传算法的示例代码，此外，还会讲解父代基因的适应度高而产生的子代适应度降低的原因，以及选择的重要性。

遗传算法思想

遗传算法主要的中心思想为“适者生存，优胜劣汰”来找到全局最优解。

在遗传算法中，首先会诞生一个随机的种群，这个种群的基因库随机生成。

因为环境(目标)的限制，种群中每个个体适应环境的能力（适应度）不同，因此导致每个个体能够遗传下去的概率不同

具有更高适应度的个体会享有更高的遗传概率，即能够以自身的基因段繁殖出子代。

在繁殖过程中，两个个体的基因序列会发生交叉，从而诞生的新的个体拥有两个父代的基因段。

子代还有概率发生变异，基因序列发生突变。

在不断地迭代中，个体会发生不断地进化，适应度会提高。

需要注意的相关概念

初始化种群：是随机选择一组个体，每一个个体都表示一组基因序列，因此实际上是随机选择了几组基因序列
计算适应度：适应度是指每一个个体对环境的适应程度，也可以理解为基因的进化方向，基因在一轮一轮迭代中，尝试不断地向这个这个方向进化，以提高自身的适应度。在算法中，表现为对目标的接近程度。在实际应用中，可根据修改适应度函数，来达成自身的目的。
选择：选择负责繁殖下一代的个体，在实际应用中，可以调整选择的策略，比如：随机选择，提高优秀个体的选择权重，只选最优个体的等。不同的选择策略会产生不同的遗传效应。一般的选择策略都会提高更具适应性的个体被选中的概率，将遗传物质传递给下一代，但同时允许低适应性的个体也有遗传的几率，这样不会完全摒弃其遗传物质。
交叉：将父代的基因序列交叉，以建立新的个体（子代），交叉提高了物种进化的速度，在算法中，表现为提升迭代速度。可以有多种不同的交叉策略，主要根据实际情况做调整。
变异：目的是更新种群，将新模式引入基因序列中，在算法中，表现为鼓励在解空间的未知领域中探索，帮助算法跳出局部最优解。
物种多样性：物种的多样是意味着算法在解空间探索的广度，防止陷入某一局部最优解。增加种群的数量，采取更随机的选择策略和交叉策略，提高变异的概率等手段，皆能提高物种多样性。但过度的物种多样性可能会更容易导致子代丢失父代的优秀基因，导致迭代速度下降，甚至无法满足需求。
进化速度：进化速度可以理解为梯度下降时的步长，也可以理解为单次迭代时靠近最优值得速度。通过更加激进的选择策略，如：只选最优个体等，会加速进化，但同时会导致，物种多样性的降低，可能会导致陷入局部最优解。
参数敏感性：遗传算法对参数是具有较高的敏感度的，即，参数的修改对算法能否找到最优解，是否陷入局部最优解以及迭代速度都有较大影响。调参是门艺术，可以理解为掌握进化速度与物种多样性之间的平衡。
终止条件：算法的终止条件是达到迭代次数，也可以是达到了预期的值

算法优点

全局最优：相较于大多数的传统搜索和优化算法（尤其是基于梯度的搜索和优化算法），遗传算法更有可能找到全局最优解，而不容易陷入局部最优解（这是梯度算法的一大难点）
处理复杂问题：遗传算法仅需要依靠每个个体的适应度得分，而不在乎适应度函数其中的运算（即使适应度函数中包含导数等），因此它可以用于解决具有复杂数学表示的问题。
处理缺乏数学表示的问题：与上一条同样，遗传算法依靠的是适应度的结果而不在乎如何得出适应度的过程，因此它甚至可以用于缺乏数学表示的问题，只要在适应度函数中将逻辑表现出来，能够比较不同个体的好坏，即可运行遗传算法。
耐噪音：一些问题中可能存在噪音现象，这一现象会干扰到大多数的传统搜索算法，但遗传算法对此具有鲁棒性。这要归功于反复交叉和重新评估个体的操作。
并行处理：遗传算法非常适合并行化和分布式处理，适应度是针对每个个体独立运算，因此可以同时评估所有个体的适应度。
持续学习：遗传算法可以一直持续，随着环境的变化而使种群重新适应它们，但这要求环境的变化速度小于种群的进化速度。

算法缺点

超参数调整：遗传算法的行为由一群超参数控制，这使得研究人员需要手动调整参数，这考验研究人员的经验，在某些问题上，无法给出超参数时，遗传算法效果会大打折扣
计算密集：种群规模较大时可能会需要大量的计算，在达到良好结果前非常耗时，可以通过选择超参数，并行处理以及在某些情况下缓存中间值来缓解这个问题
过早趋同：如果某一个体的适应能力比种群的其他个体要强得多，那么它的重复性可能足以覆盖整个种群，导致算法过早的进入了局部最优值，而不会去寻找全局最优，为防止这种情况的发生，需要保证物种的多样性。
无法保证解的质量：遗传算法的使用并不能保证找到当前问题的全局最大值（但几乎所有的搜索和优化算法都存在此类问题，除非它是针对特定类型问题的解析解）。通常，遗传算法在适当使用时可以在合理的时间内提供良好的解决方案。

代码示例

下面给出示例代码：

 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


import random

# 初始化种群
def initialize_population(pop_size, gene_length):
 return [random.choices([0, 1], k=gene_length) for _ in range(pop_size)]

# 适应度函数的设计是为了评估一个个体的优劣性
# 通常，适应度函数是优化问题中的目标函数或其变体
def fitness_function(individual):
 return sum(individual)

# 选择父代
def select_parents(population, fitnesses):
 return random.choices(population, weights=fitnesses, k=2)

# 交叉方法：选择特定的交换位置，交换两个个体的基因
def crossover(parent1, parent2):
 crossover_point = random.randint(1, len(parent1) - 1)
 child1 = parent1[:crossover_point] + parent2[crossover_point:]
 child2 = parent2[:crossover_point] + parent1[crossover_point:]
 return child1, child2

# 变异方法：当随机数小于变异率时，变异：将基因值翻转
def mutate(individual, mutation_rate):
 return [1 - gene if random.random() < mutation_rate else gene for gene in individual]

def genetic_algorithm(pop_size, gene_length, generations, mutation_rate):
 # 初始化种群
 population = initialize_population(pop_size, gene_length)

 for _ in range(generations):
 # 计算适应度
 fitnesses = [fitness_function(ind) for ind in population]
 new_population = []

 for _ in range(pop_size // 2):
 # 选择父代
 parent1, parent2 = select_parents(population, fitnesses)
 # 交叉
 child1, child2 = crossover(parent1, parent2)
 # 变异
 new_population.extend([mutate(child1, mutation_rate), mutate(child2, mutation_rate)])
 # 更新种群
 population = new_population
 # 选择最优个体
 best_individual = max(population, key=fitness_function)
 # 返回最优个体及其适应度
 return best_individual, fitness_function(best_individual)

# 使用示例
best_solution, best_fitness = genetic_algorithm(pop_size=100, gene_length=20, generations=50, mutation_rate=0.01)
print(f"Best solution: {best_solution}")
print(f"Best fitness: {best_fitness}")

各函数解释

initialize_population

1
2
3


# 初始化种群
def initialize_population(pop_size, gene_length):
 return [random.choices([0, 1], k=gene_length) for _ in range(pop_size)]

这里用了random.choices方法、列表推导式

random.choices() 函数

random.choices(population, k) 是 Python 的 random 模块中的一个函数，用于从 population 中随机选取 k 个元素，返回一个包含选定元素的列表。

population: 这是一个序列，可以是列表、元组、字符串等。random.choices() 会从这个序列中随机选取元素。

k: 这是一个整数，指定了要从 population 中选取多少个元素。

for _ in range(pop_size)

这是一个列表推导式的部分。for _ in range(pop_size) 表示我们将执行 pop_size 次循环。

range(pop_size) 生成一个从 0 到 pop_size-1 的序列（不包括 pop_size）。

_ 是一个常见的约定，表示这个循环变量我们并不打算使用。所以这里的 _ 不代表任何实际的值，纯粹是用来控制循环次数。

因此，for _ in range(pop_size) 表示循环 pop_size 次。

结合起来

这行代码实际上是生成一个列表，列表中包含了 pop_size 个元素，每个元素都是一个长度为 gene_length 的列表。每个长度为 gene_length 的列表是通过 random.choices([0, 1], k=gene_length) 随机生成的，其中每个元素是从 [0, 1] 中选取的。

fitness_function

1
2
3
4


# 适应度函数的设计是为了评估一个个体的优劣性
# 通常，适应度函数是优化问题中的目标函数或其变体
def fitness_function(individual):
 return sum(individual)

该函数为适应度函数，其目的是计算individual个体的基因序列中为1的个数。也就是说，当一个个体的基因中，1的个数越多，其适应度越高

select_parents

1
2
3


# 选择父代
def select_parents(population, fitnesses):
 return random.choices(population, weights=fitnesses, k=2)

这里重复使用了random.choices方法，与上面的大差不差，唯一的区别是增加了weights参数

weights：

这是一个与 population 长度相同的可迭代对象（通常是列表或元组），它表示每个元素被选中的概率权重。

权重越大的元素被选中的概率越高。注意，权重值的大小并不是选中的概率本身，而是相对的。例如，如果 weights 中的一个值是 2，而另一个是 1，那么前者的选中概率是后者的两倍。

例如，如果 population = ['A', 'B', 'C', 'D'] 且 weights = [0.1, 0.3, 0.5, 0.1]，那么 C 的选中概率最大，A 和 D 的概率最小。

crossover

1
2
3
4
5
6


# 交叉方法：选择特定的交换位置，交换两个个体的基因
def crossover(parent1, parent2):
 crossover_point = random.randint(1, len(parent1) - 1)
 child1 = parent1[:crossover_point] + parent2[crossover_point:]
 child2 = parent2[:crossover_point] + parent1[crossover_point:]
 return child1, child2

该函数随机选择了一个交叉点，crossover_point，以该点为基础作为切割，将父代分为两端，并两个相互交换一段，形成了两个新的子代。

random.randint(1,len(parent1)-1)：

random.randint()会随机生成一个整数，范围从1到len(parent1)-1（parent1 和 parent2 的长度相同）。

选择 1 到 len(parent1) - 1 范围内的数字是因为交叉点不能选择在序列的两端（即不允许交叉点为 0 或序列的最后一个位置）。这样可以确保父代的两部分都会参与到交叉中。

mutate

1
2
3


# 变异方法：当随机数小于变异率时，变异：将基因值翻转
def mutate(individual, mutation_rate):
 return [1 - gene if random.random() < mutation_rate else gene for gene in individual]

这里同样采用了列表表达式，遍历一个个体内的所有基因。

如果随机数小于变异率，则会导致基因值翻转，否则基因将保持原样。

genetic_algorithm

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


def genetic_algorithm(pop_size, gene_length, generations, mutation_rate):
 # 初始化种群
 population = initialize_population(pop_size, gene_length)

 for _ in range(generations):
 # 计算适应度
 fitnesses = [fitness_function(ind) for ind in population]
 new_population = []

 for _ in range(pop_size // 2):
 # 选择父代
 parent1, parent2 = select_parents(population, fitnesses)
 # 交叉
 child1, child2 = crossover(parent1, parent2)
 # 变异
 new_population.extend([mutate(child1, mutation_rate), mutate(child2, mutation_rate)])
 # 更新种群
 population = new_population
 # 选择最优个体
 best_individual = max(population, key=fitness_function)
 # 返回最优个体及其适应度
 return best_individual, fitness_function(best_individual)

种群初始化
generations表示世代数，即迭代次数
计算适应度
pop_size // 2表示更新次数，因为一次更新用到两个父代，并产生两个子代，因此更新次数是种群数的1/2。//表示地板除法，结果是向下取整的商
选择父代时，采用的是增加优秀个体的权重策略。这样保证优秀基因有更大概率遗传，也保证了其它个体有遗传的概率，不摒弃“劣质基因”
交叉采用的策略是定点交叉段
变异率为0.01，即随机数小于0.01时则会发生变异，变异策略为单个基因变异，即每个基因变异都是独立的概率，且每个基因都有概率变异
待更新结束后，种群更新的策略为：新产生的子代全部替代父代，形成新的种群。不保留优质父代。

从上面我们可以看到，不仅仅是适应度函数会更具不同的常见发生变化，选择函数，交叉函数，变异函数和更新种群都可以采用不同的策略。这需要使用者的智慧根据环境选择最优的策略搭配。

尤其需要注意的是，在选择策略时还要兼顾超参数的影响，避免陷入过度进化和物种多样性危机。

父代基因适应度高而子代基因适应度降低的原因

在进行交叉时，有可能出现两个父代基因的适应度高而结合后产生的子代基因的适应度反而降低的情况，

如上面的代码中，当父代1的基因序列为：[1,0,1,1,1]，父代2的基因序列为：[1,1,1,0,1]，此时做交叉，可能诞生的子代基因序列为：[1,0,1,0,1]，基因的适应度反而降低。

1. 交叉操作引入的不利基因组合

交叉操作的基本思路是将两个父代基因的部分基因片段交换，从而产生新的子代。虽然这种方法通常能够产生适应度较高的后代，但也存在以下几种可能导致子代适应度降低的情况：

不良基因组合：两个适应度较高的父代可能有一些部分基因（如某些基因位的0和1组合）对适应度产生较大影响。交叉操作时，基因片段的交换可能会把这些不良基因组合带到子代中，从而降低子代的适应度。
局部最优：即使父代的适应度较高，但它们可能都处于某个局部最优解。如果交叉操作导致子代在搜索空间中“跳出”了父代所在的局部最优区间，可能会产生较低的适应度，甚至带来“坏”基因组合，使得子代的适应度下降。

2. 变异操作对子代的影响

变异操作在一定概率下会对个体的基因进行随机的改变。虽然变异有时能帮助算法跳出局部最优解，但也有可能导致子代的适应度下降，特别是当变异幅度过大或频率过高时。具体来说：

过度变异：如果变异操作过于频繁或变异幅度过大，子代可能会失去父代的优良特性，从而导致适应度下降。
适应度函数的复杂性：适应度函数可能会对某些特定基因组合非常敏感，稍微的变异就可能导致适应度的显著下降。

3. 遗传算法的平衡

遗传算法的设计目标是通过交叉和变异操作从父代产生更好的子代，但也不可避免地会出现"适应度降低"的情况。这种现象尤其在遗传算法的初期或未经过多代优化时较为常见。

探索与开发的平衡：如果在每一代中都强制选择适应度较高的个体，并进行交叉，可能会导致种群中的多样性下降，从而减缓整体的进化速度。变异和交叉可以在一定程度上提供“探索”的机制，帮助算法避免陷入局部最优解。然而，过度的探索也可能导致适应度下降。

4. 交叉操作的种类

交叉操作的具体方式也会影响其效果。不同的交叉方法（例如单点交叉、多点交叉、均匀交叉等）可能会在不同情况下对适应度产生不同的影响。某些交叉方法可能会更容易生成适应度较低的子代，而其他方法则能更好地保持或提高适应度。

5. 种群的多样性

遗传算法中的种群多样性对于防止“过早收敛”至局部最优解至关重要。如果种群的多样性减少（例如，所有个体都开始趋同于相似的基因组合），那么交叉操作可能会限制新解的生成，从而导致适应度的下降。

6. 选择压力

如果选择操作过于强烈（例如，每代仅选择适应度最高的个体进行交叉），可能会导致种群中的多样性迅速下降，甚至产生“过度优化”的现象。这样，在某些情况下，交叉出来的子代可能并不会比父代更好，反而会出现适应度下降的情况。

小结

是的，确实存在父代适应度较高时，交叉和变异操作可能导致子代适应度降低的情况。虽然遗传算法的设计目标是通过交叉和变异产生更适应环境的个体，但这种过程是随机的，并不总是能直接产生更好的解。为了应对这种问题，通常可以通过以下方法进行改进：

选择策略优化：适当调整选择压力，避免过早收敛。
交叉和变异操作调整：设计合理的交叉和变异策略，保证种群多样性，同时减少不必要的适应度降低。
引入精英策略：保留最优个体，确保最好的基因不会丢失。

通过这些策略，遗传算法可以在进化过程中最大程度地避免出现适应度降低的现象，同时维持算法的多样性和全局搜索能力。

选择

选择是门艺术，采取不同的选择策略会给予基因进化以不同的选择压力，不同的选择压力则会影响着基因进化的方向和速度，甚至印象基因是否进化

选择压力

选择压力是指最佳个体选中的概率与平均选中的概率的比值。

换句话说：你是否过分在意最佳个体，越提高最佳个体的选中概率，则选择压力越大，反之越小。

类比：社会中，给予有能力的人的优待越大，则压力越大（大家都拼命内卷，都想做变得比别人更出众，结果演化出有钱人表示有能力，有样貌表示有能力等，以局部能力概括全部能力的现象）。给予有能力的人的优待越小，则压力越小（大家都选择躺平，因为没有动力去成为有能力的人）。

因此，适合的压力才能更好地让推动大家进步。

在遗传算法中：

选择压力小（比如随机选择），会导致群体不进化
选择压力大（比如只选择最优个体），会导致收敛到局部最优解

选择方式

轮盘赌选择（随机选择）：又称比例选择算子，基本思想是：个体被选中的概率与其适应度函数的比值成正比
确定性选择：从子代或父代中选择最优的个体
竞赛选择：从种群中随机选择t个个体并记下对应适应度，返回t个个体中最好的个体，同时具备随机性和确定性

参考文章

遗传算法 (Genetic Algorithm, GA)-CSDN博客

遗传算法与深度学习实战（4）——遗传算法（Genetic Algorithm）详解与实现-CSDN博客

智能体入门——遗传算法与Qlearning_genetic algorithm和qlearning的区别和关系-CSDN博客

选择和适应度函数20160510 - 百度文库