使用遗传算法构建 CoinTex 游戏代理

于 2025-04-15 01:52:31 发布
阅读量909 收藏 9
点赞数 18
文章标签： pytorch 人工智能 python 个人开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2501_90323865/article/details/147236427
版权

在当今的游戏世界中，游戏环境变得越来越复杂，众多不同的因素都会影响决策的制定。人工智能领域的一个重要分支就是致力于构建能够像专业玩家一样做出正确决策的游戏代理。在这篇教程中，我们将详细探讨如何仅使用遗传算法来构建一个能够玩名为 CoinTex 游戏的代理。

CoinTex 游戏概述

CoinTex 是一款使用 Kivy 框架开发的开源跨平台 Python 3 游戏。该游戏的源代码可以在 GitHub 上找到，它是《使用 Kivy 和 Android Studio 在 Python 中构建 Android 应用》这本书的一部分。游戏的主要 Python 脚本名为 main.py，其 GUI（小部件树）则在名为 cointex.kv 的 KV 文件中构建。

运行游戏时，只需运行 main.py 脚本。在 Mac/Linux 终端中，要使用 python3 而不是 python，因为 CoinTex 是用 Python 3 开发的。游戏目前有 24 个关卡，玩家需要逐个击败前一个关卡才能激活下一个关卡。进入关卡后，玩家通过触摸屏幕来移动角色，屏幕顶部会显示已收集的硬币数量、本关的总硬币数量、当前关卡编号以及玩家的生命值。玩家的目标是在保持生命值大于 0 的情况下收集所有硬币。

游戏的工作原理

游戏运行后，首先调用的方法是 on_start()，该方法会根据玩家上次通过的关卡激活相应的关卡，之后会打开已激活关卡的网格。当用户选择一个关卡并在进入之前，会调用 screen_on_pre_enter() 方法，在这个方法中，会随机选择屏幕上硬币的位置。进入关卡后，screen_on_enter() 方法会被调用，它会启动怪物和火焰的移动。

怪物和火焰移动时，会为它们的 pos_hint 属性分配新的位置。在 cointex.kv 文件中，为每个怪物和火焰都分配了一个回调方法，当 pos_hint 属性发生变化时会调用这些方法。玩家也有一个 pos_hint 属性，当它改变时，会调用 char_postion_hint() 方法，该方法会比较玩家和所有未收集硬币的位置，以检查是否发生碰撞。

获取关键信息

要构建游戏代理，我们需要获取一些关键信息，包括关卡屏幕的引用、硬币的位置、怪物的位置和火焰的位置。

  • 获取屏幕引用：对于每个关卡，都有一个对应的 Kivy 屏幕，通过 app.root.screens[lvl_num] 可以获取该关卡屏幕的引用，其中 app 是 CointexApp 类的实例，lvl_num 是关卡编号。
  • 获取硬币位置：屏幕中有一个名为 coins_ids 的字典，它保存着未收集硬币的位置。收集到的硬币会从该字典中移除。通过 curr_screen.coins_ids 可以获取该字典。
  • 获取怪物位置：每个屏幕都有一个名为 num_monsters 的属性，它保存着屏幕上怪物的数量。通过 curr_screen.ids[‘monster’+str(monst_num)+‘_image_lvl’+str(lvl_num)] 可以获取怪物的引用，进而获取其位置。
  • 获取火焰位置：火焰的处理方式与怪物类似，通过 curr_screen.ids[‘fire’+str(i+1)+‘_lvl’+str(lvl_num)] 可以获取火焰的引用和位置。

代理的工作原理

我们构建的游戏代理仅使用遗传算法来做出决策，告诉玩家角色该移动到哪里，不使用任何机器学习或深度学习模型。代理的任务是在避免与怪物和火焰碰撞的同时收集所有硬币。

代理在决定玩家下一个位置时，会先设定一个目标硬币，然后根据遗传算法当前种群中的解决方案，选择能让玩家尽可能接近目标硬币的解决方案。具体做法是计算种群中每个解决方案（位置）与目标硬币位置之间的距离，为了使遗传算法的适应度函数成为最大化函数，会将计算出的距离取倒数作为适应度值。

同时，代理还会考虑怪物和火焰的位置。如果某个解决方案靠近至少一个怪物或火焰，会对其适应度值进行惩罚，降低其值；如果远离，则增加其值。

实现步骤

  1. 安装 PyGAD：要继续这个项目，必须安装 PyGAD 库，可以从 PyPI 下载其 wheel 文件，也可以使用 pip 安装，命令为 pip install pygad>=2.4.0（在 Linux/Mac 上使用 pip3）。
  2. 构建适应度函数：在遗传算法中，适应度函数接受算法产生的解决方案作为输入，并返回一个适应度值作为输出。适应度值越高，解决方案越好。在 PyGAD 中，适应度函数是一个普通的 Python 函数，接受解决方案和解决方案在种群中的索引作为参数。
def fitness_func(solution, solution_idx):
    curr_screen = app.root.screens[lvl_num]
    coins = curr_screen.coins_ids
    if len(coins.items()) == 0:
        return 0
    curr_coin = coins[list(coins.keys())[0]]
    curr_coin_center = [curr_coin.pos_hint['x'], curr_coin.pos_hint['y']]
    output = abs(solution[0] - curr_coin_center[0]) + abs(solution[1] - curr_coin_center[1])
    output = 1.0 / output
    monsters_pos = []
    for i in range(curr_screen.num_monsters):
        monster_image = curr_screen.ids['monster'+str(i+1)+'_image_lvl'+str(lvl_num)]
        monsters_pos.append([monster_image.pos_hint['x'], monster_image.pos_hint['y']])
    for monst_pos in monsters_pos:
        char_monst_h_distance = abs(solution[0] - monst_pos[0])
        char_monst_v_distance = abs(solution[1] - monst_pos[1])
        if char_monst_h_distance <= 0.3 and char_monst_v_distance <= 0.3:
            output -= 300
        else:
            output += 100
    fires_pos = []
    for i in range(curr_screen.num_fires):
        fire_image = curr_screen.ids['fire'+str(i+1)+'_lvl'+str(lvl_num)]
        fires_pos.append([fire_image.pos_hint['x'], fire_image.pos_hint['y']])
    for fire_pos in fires_pos:
        char_fire_h_distance = abs(solution[0] - fire_pos[0])
        char_fire_v_distance = abs(solution[1] - fire_pos[1])
        if char_fire_h_distance <= 0.3 and char_fire_v_distance <= 0.3:
            output -= 300
        else:
            output += 100
    fitness = output
    return fitness
  1. 构建世代回调函数：这个函数会在遗传算法的每一代完成后被调用，用于找到上一代进化出的种群中的最佳解决方案，并根据该解决方案的位置移动玩家。
last_fitness = 0
def callback_generation(ga_instance):
    global last_fitness
    best_sol_fitness = ga_instance.best_solution()[1]
    fitness_change = best_sol_fitness - last_fitness
    curr_screen = app.root.screens[lvl_num]
    last_fitness = best_sol_fitness
    coins = curr_screen.coins_ids
    if len(coins.items()) == 0 or curr_screen.character_killed:
        return "stop"
    elif len(coins.items()) != 0 and fitness_change != 0:
        best_sol = ga_instance.best_solution()[0]
        app.start_char_animation(lvl_num, [float(best_sol[0]), float(best_sol[1])])
  1. 创建遗传算法实例：使用 PyGAD 的 GA 类创建遗传算法的实例，并设置必要的参数。
import pygad
ga_instance = pygad.GA(num_generations=9999, num_parents_mating=300, fitness_func=fitness_func, sol_per_pop=1000, num_genes=2, init_range_low=0.0, init_range_high=1.0, random_mutation_min_val=0.0, random_mutation_max_val=1.0, mutation_by_replacement=True, callback_generation=callback_generation, delay_after_gen=app.root.screens[lvl_num].char_anim_duration)
  1. 启动遗传算法：为了避免阻塞应用程序的主线程，我们在一个新线程中运行遗传算法。在 CointexApp 类的 screen_on_enter() 方法中启动这个新线程。
import threading
class CollectCoinThread(threading.Thread):
    def __init__(self, screen):
        super().__init__()
        self.screen = screen
    def run(self):
        ga_instance = pygad.GA(num_generations=9999, num_parents_mating=300, fitness_func=fitness_func, sol_per_pop=1000, num_genes=2, init_range_low=0.0, init_range_high=1.0, random_mutation_min_val=0.0, random_mutation_max_val=1.0, mutation_by_replacement=True, callback_generation=callback_generation, delay_after_gen=self.screen.char_anim_duration)
        ga_instance.run()

global lvl_num
lvl_num = screen_num
collectCoinThread = CollectCoinThread(screen=curr_screen)
collectCoinThread.start()

总结

通过本教程，我们了解了如何使用遗传算法为 CoinTex 游戏创建一个游戏代理。这个代理能够在复杂的游戏环境中，即使在有许多硬币、怪物和火焰的困难关卡中，也能高效地工作。使用开源的 Python 库 PyGAD 实现遗传算法，为我们开发游戏代理提供了便利。如果你对代码感兴趣，可以在 GitHub 上找到 CoinTex 和代理的源代码。

t0_54program
关注
ChatGPT 使用 拓展资料：强化学习DQN 单模型、双模型、DoubleDQN、DuelingDQN
段智华的博客
03-26 3684
ChatGPT 使用 拓展资料：强化学习DQN 单模型、双模型。
PyTorch实战：强化学习入门
AI天才研究院
02-18 202
1. 背景介绍 1.1 什么是强化学习 强化学习（Reinforcement Learning，简称RL）是一种机器学习方法，它通过让智能体（Agent）在环境（Environment）中采取行动，根据环境给出的奖励（Reward）或惩罚（Penalty）来学习最优策略。强化学习的目标是让智能体在长期
掌握PyTorch的策略梯度和Qlearning实现
AI天才研究院
01-25 678
1.背景介绍 策略梯度和Q-learning是两种非常重要的强化学习算法，它们在人工智能和机器学习领域具有广泛的应用。在本文中，我们将深入探讨PyTorch实现策略梯度和Q-learning的核心概念、算法原理、最佳实践以及实际应用场景。 1. 背景介绍 强化学习是一种机器学习方法，它涉及到一个智能体与环境之间的交互过程。智能体通过执行动作来影响环境，并从环境中接收反馈来学习如何取得最大化的...
DDQN的Pytorch实现.zip
05-19
使用Pytorch和多项式分布采样实现DDQN算法 DDQN和Nature DQN一样，也有一样的两个Q网络结构。在Nature DQN的基础上，通过解耦目标Q值动作的选择和目标Q值的计算这两步，来消除过度估计的问题。
强化学习与 PyTorch【1.0】
最新发布
qq_43416206的博客
04-05 909
其实，在本书的开头就给人工智能下定义是不合适的， 因为定义下得不好， 很可能会误导读者。但是， 对人工智能的定义没有基本的认识， 也是一件很麻烦的事情，因为很可能没过多久就会有读者开始纠结于“这种人工智能够不够智能”“这个东西配不配叫人工智能” 这样基本的而充满争议的问题了。需要注意的是，机器学习也好，人工智能也罢，这两个词汇本身就在无形中给人一种误导。它们让人们觉得， 机器是自己在学习的， 由人制造出来的这个“智能”的东西自己有分析、 思考、进化的能力。
强化学习：DQN（转载）
qq_30934313的博客
01-10 210
关于强化学习中DQN 主要内容： 强化学习是什么？ 主要表现的3个方面 ： 1 使用神经网络逼近函数 2 使用经验回放进行训练 3 设置单独的target DQN 计算Q值 详见http://www.broadview.com.cn/article/419382 ...
【强化学习】深度Q网络(DQN)求解倒立摆问题 + Pytorch代码实战
热门推荐
知不足而奋进，望远山而前行
10-22 2万+
Agent 必须在两个动作之间做出决定 - 向左或向右移动推车 - 以使连接到它的杆保持直立。 深度 Q\mathrm{Q}Q 网络算法是这样的，我们初始化两个网络 ：估计网络 QQQ 和 目标网络 Q^，Q^\hat{Q} ， \hat{Q}Q^​，Q^​ 就等于 QQQ ，一开始 目标网络 Q^\hat{Q}Q^​ 与原来的 QQQ 网络是一样的。在每一个回合中，我们用演员与环境交互，在每一次交互的过程中，都会得到一个 状态 sts_tst​ ，会采取某一个动作 at。a_{t 。}at。​ 怎么知道采
pytorch DQN实战
qq_45092173的博客
03-05 464
Deep Q-Network实战 示例一立杆子 示例一源自莫烦pytorch教学4.5, 原文链接：https://www.bilibili.com/video/av15997678?p=27 """ View more, visit my tutorial page: https://morvanzhou.github.io/tutorials/ My Youtube Channel: http...
强化学习算法：此存储库包含大多数基于pytorch实现的经典深度强化学习算法，包括-DQN，DDQN，Dualling Network，DDPG，SAC，A2C，PPO，TRPO。 （更多算法仍在进行中）
01-30
深度强化学习算法 该存储库将使用PyTorch实现经典的深度强化学习算法。 该存储库的目的是为人们提供清晰的代码，以供他们学习深度强化学习算法。 将来，将添加更多算法，并且还将保留现有代码。 当前实施 深度Q学习网络（DQN） 基本DQN 双Q网络 决斗网络架构 深度确定性策略梯度（DDPG） 优势演员评判（A2C） 信任区域策略梯度（TRPO） 近端政策优化（PPO） 使用克罗内克因素信任区域（ACKTR）的演员评论家 软演员评论（SAC） 更新信息 :triangular_flag: 2018年10月17日-在此更新中，大多数算法已得到改进，并添加了更多关于图的实验（DPPG除外）。 PPO现在支持atari游戏和mujoco-env 。 TRPO非常稳定，可以得到更好的结果！ :triangular_flag: 2019-07-15-在此更新中，不再需要为openai基准安装。 我在rl__utils模块中集成了有用的功能。 DDPG也重新实现，并支持更多结果。 自述文件已被修改。 代码结构也有微小的调整。 :triangular_flag: 201
【PyTorch深度强化学习】：精通DQN与DDPG算法（专家级攻略）
[【PyTorch深度强化学习】：精通DQN与DDPG算法（专家级攻略）](https://d3i71xaburhd42.cloudfront.net/e6a1640c03c50a55ef3e00a0592dbb0851fe33bb/3-Figure1-1.png) # 1. 深度强化学习基础 在深度强化学习（DRL）...
【PyTorch入门到精通】：深度学习神经网络构建必备技能
PyTorch是一个流行且功能丰富的深度学习框架，广泛应用于研究和工业界。本文首先介绍了PyTorch框架的基本概念和核心组件，然后详细探讨了其基础操作，包括张量的使用、自动求导机制，以及如何构建和管理深度学习模型...
DDQN_Mario:超级马里奥兄弟的Pytorch-DDQN实现
05-03
超级马里奥兄弟的Pytorch-DDQN实现 该项目和实现本文的 必需的 结果 参考 nailo2c / dqn-mario
Python-深度强化学习PyTorch实现集锦
08-11
This repository contains most of classic deep reinforcement learning algorithms, including - DQN, DDPG, A3C, PPO, TRPO. (More algorithms are still in progress)
【PyTorch强化学习优化】：梯度裁剪与熵正则化的终极策略
![【PyTorch强化学习优化】：梯度裁剪与熵正则化的终极策略]...PyTorch是一个流行的深度学习框架，其动态计算图和易用性使得它在强化学习领域有着
《边做边学深度强化学习：PyTorch程序设计实践》——6.2DDQN
longgegeo的博客
01-26 1304
重新实现函数update_target_q_function，在其中执行Brain类的函数update_target_q_network，在Environment类的试验（episode）结束时，执行Agent类的函数update_target_q_function。Dueling Network是一种在动作价值函数输出层之前增加一层，用于输出状态价值V(s)和优势函数A(s,a) = Q(s,a)-V(s)的方法，学习状态价值V(s)时，能独立于动作而学习状态价值V(s)，具有提高学习性能的优点。
基于Pytorch的强化学习(DQN)之 Multi-agent 训练架构
ZDDWLIG的博客
04-03 8744
目录 1. 引言 2. 训练架构 2.1 Fully decentralized 2.2 Fully centralized 2.3 Centralized&Decentralized 1. 引言 我们上一次讲到了Multi-agent的基本概念，现在来讲讲具体的训练方法，以Actor-Critic方法为例。 2. 训练架构 我们知道在Single-agent中的Actor-Critic方法中需要一个策略函数 作为Actor进行执行action，还有一个价值函数 进
DQN原理及PyTorch实现【强化学习】
新缸中之脑
12-02 724
欢迎来到我们的强化学习系列的第三部分。在上两篇博客中，我们介绍了强化学习中的一些基本概念，并研究了多臂bandit问题及其求解方法。这篇博客会有点长，因为我们将首先学习一些新概念，然后应用深度学习来构建深度 RL 代理。然后我们将训练该代理来平衡车杆。可以在访问这篇博客对应的代码库。
基于Pytorch的强化学习(DQN)之 Experience Replay
ZDDWLIG的博客
03-29 2167
目录 1. 引言 2. 经验回放算法 2. 优先经验回放 2.1 抽取方法改进 2.2 学习率修正 1. 引言 我们之前学过TD 算法，基本的TD算法的思路如下 观测到一个transition 计算TD target 计算TD error 梯度下降 我们发现一个transition在使用之后就会被丢弃了，我们不会在后面使用到它，这样的训练速度就非常慢：想象AI在打boss，但是一下就被秒了，它从中获取不到足够的信息，只能一遍又一遍地去刷boss，那又需要将前面的所以关..
《白话强化学习与PyTorch》学习笔记---第八章
cat_ziyan的博客
11-11 4337
《白话强化学习与PyTorch》学习笔记-第八章 第八章用了DQN及各种改进算法来训练Gym中的atari游戏—pong 首先先来看一下官方网站中的游戏介绍： 简单来说，训练目的是使得分最大化。在这个环境中的观察结果(observation)是RGB图像，大小为（210，160，3），在2~4（随机采样）帧内重复同一个动作。从环境中得到observation后，我们会先对数据进行预处理操作： d...
pytorch实现DQN强化学习
06-01
DQN（Deep Q-Network）是一种使用深度神经网络实现的强化学习算法，用于解决离散动作空间的问题。在PyTorch中实现DQN可以分为以下几个步骤： 1. 定义神经网络：使用PyTorch定义一个包含多个全连接层的神经网络，输入为状态空间的维度，输出为动作空间的维度。 ```python import torch.nn as nn import torch.nn.functional as F class QNet(nn.Module): def __init__(self, state_dim, action_dim): super(QNet, self).__init__() self.fc1 = nn.Linear(state_dim, 64) self.fc2 = nn.Linear(64, 64) self.fc3 = nn.Linear(64, action_dim) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x ``` 2. 定义经验回放缓存：包含多条经验，每条经验包含一个状态、一个动作、一个奖励和下一个状态。 ```python import random class ReplayBuffer(object): def __init__(self, max_size): self.buffer = [] self.max_size = max_size def push(self, state, action, reward, next_state): if len(self.buffer) < self.max_size: self.buffer.append((state, action, reward, next_state)) else: self.buffer.pop(0) self.buffer.append((state, action, reward, next_state)) def sample(self, batch_size): state, action, reward, next_state = zip(*random.sample(self.buffer, batch_size)) return torch.stack(state), torch.tensor(action), torch.tensor(reward), torch.stack(next_state) ``` 3. 定义DQN算法：使用PyTorch定义DQN算法，包含训练和预测两个方法。 ```python class DQN(object): def __init__(self, state_dim, action_dim, gamma, epsilon, lr): self.qnet = QNet(state_dim, action_dim) self.target_qnet = QNet(state_dim, action_dim) self.gamma = gamma self.epsilon = epsilon self.lr = lr self.optimizer = torch.optim.Adam(self.qnet.parameters(), lr=self.lr) self.buffer = ReplayBuffer(100000) self.loss_fn = nn.MSELoss() def act(self, state): if random.random() < self.epsilon: return random.randint(0, action_dim - 1) else: with torch.no_grad(): q_values = self.qnet(state) return q_values.argmax().item() def train(self, batch_size): state, action, reward, next_state = self.buffer.sample(batch_size) q_values = self.qnet(state).gather(1, action.unsqueeze(1)).squeeze(1) target_q_values = self.target_qnet(next_state).max(1)[0].detach() expected_q_values = reward + self.gamma * target_q_values loss = self.loss_fn(q_values, expected_q_values) self.optimizer.zero_grad() loss.backward() self.optimizer.step() def update_target_qnet(self): self.target_qnet.load_state_dict(self.qnet.state_dict()) ``` 4. 训练模型：使用DQN算法进行训练，并更新目标Q网络。 ```python dqn = DQN(state_dim, action_dim, gamma=0.99, epsilon=1.0, lr=0.001) for episode in range(num_episodes): state = env.reset() total_reward = 0 for step in range(max_steps): action = dqn.act(torch.tensor(state, dtype=torch.float32)) next_state, reward, done, _ = env.step(action) dqn.buffer.push(torch.tensor(state, dtype=torch.float32), action, reward, torch.tensor(next_state, dtype=torch.float32)) state = next_state total_reward += reward if len(dqn.buffer.buffer) > batch_size: dqn.train(batch_size) if step % target_update == 0: dqn.update_target_qnet() if done: break dqn.epsilon = max(0.01, dqn.epsilon * 0.995) ``` 5. 测试模型：使用训练好的模型进行测试。 ```python total_reward = 0 state = env.reset() while True: action = dqn.act(torch.tensor(state, dtype=torch.float32)) next_state, reward, done, _ = env.step(action) state = next_state total_reward += reward if done: break print("Total reward: {}".format(total_reward)) ``` 以上就是在PyTorch中实现DQN强化学习的基本步骤。需要注意的是，DQN算法中还有很多细节和超参数需要调整，具体实现过程需要根据具体问题进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值