Coach（Intel的强化学习库）：Coach项目实战：自定义环境与Agent

Coach（Intel的强化学习库）：Coach项目实战：自定义环境与Agent1环境搭建与配置1.1安装Coach库在开始使用Coach库进行强化学习项目之前，首先需要确保你的开发环境已经安装了Coach库。Coach是Intel开发的一个用于研究和开发强化学习算法的库，它提供了丰富的API和工具，使得研究者和开发者能够快速构建和测试不同的强化学习模型。1.1.1安装步骤确保Python环境：Coach库支持Python3.6及以上版本。你可以通过在命令行输入python--version来检查你的Python版本。安装依赖库：Coach库依赖于一些基础的Python库，如NumPy,TensorFlow,OpenAIGym等。你可以通过以下命令安装这些依赖库：pipinstallnumpytensorflowgym安装Coach库：使用pip安装Coach库，可以通过以下命令：pipinstallcoach-rl1.1.2验证安装安装完成后，可以通过导入Coach库来验证是否安装成功。在Python环境中尝试以下代码：importcoach

#打印Coach库的版本信息

print(coach.__version__)1.2配置环境变量为了使Coach库能够正确地识别和使用你的环境，可能需要设置一些环境变量。这通常包括指定数据存储路径、日志文件位置等。1.2.1配置步骤设置数据路径：Coach库需要一个路径来存储模型、日志和数据。你可以在你的系统环境变量中设置COACH_DATA_PATH，例如：exportCOACH_DATA_PATH=/path/to/your/data配置日志路径：同样，日志文件的存储路径也可以通过环境变量COACH_LOG_PATH来指定：exportCOACH_LOG_PATH=/path/to/your/logs其他配置：根据你的具体需求，可能还需要设置其他环境变量，如GPU使用、并行处理等。这些配置通常在Coach库的文档中有详细说明。1.3验证安装在配置完环境变量后，可以通过运行一个简单的Coach库示例来验证安装和配置是否正确。下面是一个使用Coach库训练一个简单Agent的示例代码：importcoach

importgym

#创建环境

env=gym.make('CartPole-v1')

#初始化Coach的训练器

trainer=coach.Trainer(env)

#选择一个Agent模型，例如DQN

agent=coach.agents.DQNAgent(env)

#将Agent添加到训练器中

trainer.add_agent(agent)

#设置训练参数

trainer.set_params({

'num_episodes':1000,

'max_steps_per_episode':200,

})

#开始训练

trainer.train()

#打印训练结果

print("Trainingcompleted.")1.3.1代码解释创建环境：这里使用的是OpenAIGym中的CartPole-v1环境，这是一个经典的强化学习测试环境，用于测试Agent的平衡能力。初始化训练器：coach.Trainer是Coach库中的训练器类，它负责管理训练过程。选择Agent模型：coach.agents.DQNAgent是Coach库提供的DQN（DeepQ-Network）Agent模型，用于处理环境中的决策。设置训练参数：通过set_params方法设置训练的总轮数和每轮的最大步数。开始训练：调用train方法开始训练过程。打印训练结果：训练完成后，打印一条信息表示训练已完成。通过以上步骤，你已经成功搭建并配置了Coach库的环境，可以开始进行自定义环境与Agent的开发了。接下来的教程将详细介绍如何自定义环境和Agent，以及如何使用Coach库进行更复杂的强化学习项目。2理解Coach框架2.1Coach框架概述Coach是IntelLabs开发的一个开源强化学习框架，旨在简化强化学习算法的实现与环境的搭建。它提供了一个统一的接口，使得研究人员和开发者能够轻松地测试和比较不同的强化学习算法，同时支持多种环境，包括但不限于OpenAIGym、UnityML-Agents等。Coach的架构设计灵活，易于扩展，适合于进行大规模的强化学习实验。2.2关键组件解析Coach框架的核心组件包括：2.2.1环境（Environment）环境是强化学习任务的背景，定义了智能体（Agent）可以与之交互的场景。在Coach中，环境被抽象为一个类，可以是游戏、模拟器或任何其他可以被建模为马尔可夫决策过程（MDP）的系统。环境需要实现特定的接口，包括reset、step、render等方法，以支持强化学习算法的运行。示例代码fromcoachimportcore

classCustomEnvironment(core.Environment):

def__init__(self,params):

super().__init__(params)

#初始化环境参数

defreset(self):

#重置环境状态，返回初始观察

pass

defstep(self,action):

#执行动作，返回观察、奖励、是否结束、额外信息

pass

defrender(self):

#可视化环境状态

pass2.2.2智能体（Agent）智能体是Coach框架中的决策者，它根据当前的环境状态选择动作。Coach支持多种类型的智能体，包括基于策略的、基于值的和基于模型的智能体。智能体的实现需要继承自Agent基类，并实现act、train、stop等方法。示例代码fromcoachimportcore

classCustomAgent(core.Agent):

def__init__(self,params):

super().__init__(params)

#初始化智能体参数

defact(self,observation):

#根据观察选择动作

pass

deftrain(self):

#训练智能体

pass

defstop(self):

#停止训练，保存模型

pass2.2.3算法（Algorithm）算法是Coach框架中的学习机制，它定义了智能体如何从环境中学习。Coach支持多种强化学习算法，如DQN、DDPG、PPO等。算法的实现需要继承自Algorithm基类，并实现learn、predict等方法。示例代码fromcoachimportcore

classCustomAlgorithm(core.Algorithm):

def__init__(self,params):

super().__init__(params)

#初始化算法参数

deflearn(self,experiences):

#从经验中学习

pass

defpredict(self,state):

#根据状态预测动作

pass2.3强化学习算法支持Coach框架支持多种强化学习算法，包括但不限于：DQN（DeepQ-Network）：基于值的算法，使用深度神经网络近似Q函数。DDPG（DeepDeterministicPolicyGradient）：基于策略的算法，适用于连续动作空间。PPO（ProximalPolicyOptimization）：基于策略的算法，通过优化策略梯度来更新策略。这些算法在Coach中被封装为模块，可以轻松地与自定义环境和智能体集成，进行实验和研究。2.3.1示例代码：使用DQN算法fromcoachimportDQNAgent

#创建DQN智能体实例

dqn_agent=DQNAgent(params)

#训练智能体

dqn_agent.train()

#在环境中测试智能体

dqn_agent.test()通过上述组件的解析和示例代码，我们可以看到Coach框架如何通过抽象和模块化设计，提供了一个灵活且强大的平台，用于强化学习的研究和开发。3自定义环境3.1定义环境类在强化学习中，环境是Agent学习的舞台。定义一个环境类，首先需要继承自gym.Env，这是IntelCoach库中环境的基类。环境类需要实现四个主要的方法：reset(),step(),render(),和close()。3.1.1代码示例importgym

importnumpyasnp

classCustomEnvironment(gym.Env):

"""自定义环境类，继承自gym.Env"""

def__init__(self):

"""初始化环境"""

self.action_space=gym.spaces.Discrete(2)#定义动作空间

self.observation_space=gym.spaces.Box(low=0,high=255,shape=(100,100,3),dtype=np.uint8)#定义观察空间

self.state=None#环境状态

self.done=False#游戏是否结束

defreset(self):

"""重置环境到初始状态，返回初始状态"""

self.state=np.zeros(self.observation_space.shape)#重置状态

self.done=False#游戏未结束

returnself.state

defstep(self,action):

"""执行动作，返回新的状态、奖励、是否结束、额外信息"""

ifaction==0:

self.state+=1#动作0：状态增加

else:

self.state-=1#动作1：状态减少

ifnp.sum(self.state)>10000:

self.done=True#如果状态总和超过10000，游戏结束

reward=np.sum(self.state)#奖励为状态总和

returnself.state,reward,self.done,{}

defrender(self,mode='human'):

"""渲染环境，mode参数可以是'human'或'rgb_array'"""

ifmode=='human':

print(self.state)

elifmode=='rgb_array':

returnself.state

defclose(self):

"""关闭环境，释放资源"""

pass3.2实现环境交互环境与Agent的交互是通过reset()和step()方法完成的。reset()方法用于重置环境到初始状态，而step()方法则用于执行Agent的动作，并返回新的状态、奖励、是否结束游戏的标志以及额外信息。3.2.1代码示例env=CustomEnvironment()

#重置环境

observation=env.reset()

#与环境交互

for_inrange(1000):

action=env.action_space.sample()#随机选择动作

observation,reward,done,info=env.step(action)#执行动作

ifdone:

print("游戏结束")

break

#渲染环境

env.render()3.3环境状态与动作空间环境状态和动作空间是强化学习中两个关键的概念。状态空间描述了环境可能处于的所有状态，而动作空间则定义了Agent在环境中可以执行的所有动作。3.3.1代码示例#定义动作空间

env.action_space=gym.spaces.Discrete(2)#两个离散动作

#定义观察空间

env.observation_space=gym.spaces.Box(low=0,high=255,shape=(100,100,3),dtype=np.uint8)#100x100x3的RGB图像3.4测试自定义环境测试自定义环境是确保环境按预期工作的重要步骤。这通常涉及到与环境进行一系列交互，检查返回的状态、奖励和游戏结束标志是否合理。3.4.1代码示例deftest_environment(env):

"""测试环境函数"""

env.reset()#重置环境

for_inrange(100):

action=env.action_space.sample()#随机选择动作

observation,reward,done,info=env.step(action)#执行动作

ifdone:

print("游戏在第{}步结束".format(_))

break

env.render()#渲染环境

#创建并测试环境

env=CustomEnvironment()

test_environment(env)通过上述代码，我们可以创建一个自定义的环境类，定义环境的状态和动作空间，实现环境与Agent的交互，并测试环境是否按预期工作。这为使用IntelCoach库进行更复杂的强化学习项目奠定了基础。4创建自定义Agent4.1选择强化学习算法在开始创建自定义Agent之前，首先需要选择一个适合的强化学习算法。Coach库提供了多种算法，包括但不限于DQN、DDPG、PPO等。选择算法时，应考虑环境的特性，如是否为连续动作空间、环境的复杂度等。例如，对于具有离散动作空间的环境，DQN（DeepQ-Network）是一个不错的选择。DQN结合了Q-Learning的原理和深度神经网络，能够处理高维输入状态，并通过经验回放和目标网络稳定学习过程。4.1.1代码示例：选择DQN算法fromcoach.architecturesimportNatureDQNArchitecture

fromcoach.coreimportAgent

classCustomDQNAgent(Agent):

def__init__(self,env,params):

super().__init__(env,params)

self.architecture=NatureDQNArchitecture(env)4.2定义Agent类定义Agent类时，需要继承Coach库中的Agent基类，并实现必要的方法。这些方法包括初始化、选择动作、学习、保存和加载模型等。4.2.1代码示例：定义自定义Agent类fromcoach.coreimportAgent

classCustomAgent(Agent):

def__init__(self,env,params):

super().__init__(env,params)

#初始化算法、网络结构等

self.algorithm=None

work=None

defact(self,observation):

#根据当前观察选择动作

action=self.algorithm.choose_action(observation)

returnaction

deflearn(self,experiences):

#使用经验数据进行学习

self.algorithm.learn(experiences)

defsave_model(self,path):

#保存模型到指定路径

work.save(path)

defload_model(self,path):

#从指定路径加载模型

work.load(path)4.3实现Agent策略Agent策略的实现依赖于所选的算法。例如，DQN算法需要实现Q值的估计和更新，而PPO算法则需要实现策略梯度的计算和更新。4.3.1代码示例：实现DQN策略fromcoach.coreimportAgent

fromcoach.architecturesimportNatureDQNArchitecture

fromcoach.algorithmsimportDQNAlgorithm

classCustomDQNAgent(Agent):

def__init__(self,env,params):

super().__init__(env,params)

self.architecture=NatureDQNArchitecture(env)

self.algorithm=DQNAlgorithm(self.architecture,params)

defact(self,observation):

q_values=self.architecture.predict(observation)

action=self.algorithm.choose_action(q_values)

returnaction

deflearn(self,experiences):

q_values=self.architecture.predict_batch([exp.stateforexpinexperiences])

self.algorithm.learn(experiences,q_values)4.4Agent与环境的连接Agent与环境的交互是通过观察环境状态、选择动作、执行动作并接收奖励和新状态来完成的。在Coach中，这通常通过Agent类的act和learn方法实现。4.4.1代码示例：Agent与环境的交互fromcoach.coreimportAgent

fromcoach.environmentsimportCustomEnvironment

classCustomAgent(Agent):

def__init__(self,env,params):

super().__init__(env,params)

self.environment=CustomEnvironment()

defrun_episode(self):

observation=self.environment.reset()

done=False

whilenotdone:

action=self.act(observation)

next_observation,reward,done,_=self.environment.step(action)

self.learn((observation,action,reward,next_observation,done))

observation=next_observation4.4.2数据样例：环境交互数据假设我们有一个简单的环境，其中包含状态、动作、奖励等信息。以下是一个交互数据的样例：#环境交互数据样例

observation=np.array([0.1,0.2,0.3])

action=1

reward=0.5

next_observation=np.array([0.2,0.3,0.4])

done=False

#将数据打包成经验

experience=(observation,action,reward,next_observation,done)在上述代码中，observation和next_observation是环境状态的表示，action是Agent选择的动作，reward是执行动作后从环境接收到的奖励，done是一个布尔值，表示当前episode是否结束。通过这些步骤，我们可以创建一个自定义的Agent，它能够与环境进行交互，学习并优化其策略。在实际应用中，可能还需要对算法参数、网络结构等进行调整，以适应特定的环境和任务需求。5训练与评估5.1设置训练参数在使用Coach进行强化学习项目时，设置训练参数是确保模型能够有效学习的关键步骤。这些参数包括学习率、批次大小、训练轮次等，它们直接影响到训练过程的效率和最终模型的性能。#导入Coach库

fromcoachimportcore

#创建训练配置

config={

'agent_params':{

'algorithm':{

'optimizer':{

'learning_rate':0.001#设置学习率

},

'batch_size':32,#设置批次大小

'num_steps':10000#设置训练步数

}

},

'exploration':{

'exploration_policy':'epsilon_greedy',

'epsilon_decay_steps':10000,#设置epsilon衰减步数

'epsilon_initial':1.0,#设置初始epsilon值

'epsilon_final':0.1#设置最终epsilon值

}

}5.2执行训练过程一旦训练参数设置完毕，接下来就是执行训练过程。在Coach中，这通常涉及到创建环境、Agent和训练循环。#创建环境

env=core.make('MyCustomEnvironment',level='level1')

#创建Agent

agent=core.make('MyCustomAgent',params=config['agent_params'])

#开始训练

forstepinrange(config['agent_params']['algorithm']['num_steps']):

#与环境交互

state=env.reset()

done=False

whilenotdone:

action=agent.act(state)

next_state,reward,done,_=env.step(action)

agent.train(next_state,reward,done)

state=next_state5.3评估Agent性能评估Agent的性能是训练过程中的重要环节，它帮助我们了解Agent在环境中的表现。在Coach中，我们可以通过在测试环境中运行Agent并记录其得分来评估性能。#创建测试环境

test_env=core.make('MyCustomEnvironment',level='test_level')

#评估Agent

total_reward=0

num_episodes=10#设置测试的剧集数量

forepisodeinrange(num_episodes):

state=test_env.reset()

done=False

whilenotdone:

action=agent.act(state,is_evaluation=True)

next_state,reward,done,_=test_env.step(action)

total_reward+=reward

state=next_state

average_reward=total_reward/num_episodes

print(f'平均得分:{average_reward}')5.4分析训练结果训练完成后，分析结果可以帮助我们理解Agent的学习过程和性能。Coach提供了多种工具来可视化训练过程中的关键指标，如奖励、损失和epsilon值。#导入可视化库

importmatplotlib.pyplotasplt

#绘制训练过程中的奖励变化

plt.figure(figsize=(10,5))

plt.plot(agent.rewards_history)

plt.title('训练过程中的奖励变化')

plt.xlabel('训练步数')

plt.ylabel('奖励')

plt.show()通过上述步骤，我们可以使用Coach库有效地训练和评估自定义的Agent，同时对训练结果进行深入分析，以优化我们的强化学习模型。6高级主题：多Agent系统、环境并行化与自定义网络结构6.1多Agent系统在多Agent系统中，我们探讨如何在Coach中实现多个智能体在同一个环境中协同或竞争。这种设置常见于复杂的游戏环境或现实世界的多智能体场景，如交通管理、机器人协作等。6.1.1实战案例：自定义多Agent环境假设我们正在创建一个简单的多Agent环境，其中两个智能体在一个2D网格上移动，目标是同时到达一个指定的位置。我们将使用Coach的API来定义这个环境。importnumpyasnp

fromcoachimportcore

fromcoach.coreimportspaces

classMultiAgentGrid(core.Env):

def__init__(self):

self.grid_size=5

self.agent_positions=[(0,0),(4,4)]

self.target_position=(2,2)

self.action_space=spaces.Discrete(4)#上下左右四个方向

self.observation_space=spaces.Box(low=0,high=1,shape=(self.grid_size,self.grid_size),dtype=32)

defreset(self):

self.agent_positions=[(0,0),(4,4)]

return[self._get_obs(i)foriinrange(2)]

defstep(self,actions):

rewards=[0,0]

dones=[False,False]

infos=[{}for_inrange(2)]

fori,actioninenumerate(actions):

ifaction==0:#上

self.agent_positions[i]=(max(0,self.agent_positions[i][0]-1),self.agent_positions[i][1])

elifaction==1:#下

self.agent_positions[i]=(min(self.grid_size-1,self.agent_positions[i][0]+1),self.agent_positions[i][1])

elifaction==2:#左

self.agent_positions[i]=(self.agent_positions[i][0],max(0,self.agent_positions[i][1]-1))

elifaction==3:#右

self.agent_positions[i]=(self.agent_positions[i][0],min(self.grid_size-1,self.agent_positions[i][1]+1))

ifself.agent_positions[i]==self.target_position:

rewards[i]=1

dones[i]=True

ifall(dones):

dones=[True,True]

else:

dones=[False,False]

return[self._get_obs(i)foriinrange(2)],rewards,dones,infos

def_get_obs(self,agent_id):

obs=np.zeros((self.grid_size,self.grid_size),dtype=32)

obs[self.agent_positions[agent_id]]=1

obs[self.target_position]=2

returnobs

defrender(self,mode='human'):

grid=np.zeros((self.grid_size,self.grid_size),dtype=32)

foriinrange(2):

grid[self.agent_positions[i]]=1

grid[self.target_position]=2

print(grid)6.1.2自定义多Agent智能体在定义了环境之后，我们需要创建智能体来与环境交互。在Coach中，可以使用MultiAgentTrainer来训练多个智能体。fromcoachimportcore

fromcoach.coreimportTrainer

classMultiAgentTrainer(Trainer):

def__init__(self,env,agents):

super().__init__(env)

self.agents=agents

deftrain(self):

obs=self.env.reset()

foragentinself.agents:

agent.reset(obs)

done=False

whilenotdone:

actions=[agent.act(obs)foragent,obsinzip(self.agents,obs)]

obs,rewards,dones,_=self.env.step(actions)

foragent,reward,doneinzip(self.agents,rewards,dones):

agent.observe(reward,done)

deftest(self):

obs=self.env.reset()

foragentinself.agents:

agent.reset(obs)

done=False

whilenotdone:

actions=[agent.act(obs,is_test=True)foragent,obsinzip(self.agents,obs)]

obs,_,dones,_=self.env.step(actions)6.2环境并行化环境并行化是强化学习中加速训练过程的一种常见技术。通过并行运行多个环境实例，可以收集更多的经验数据，从而提高学习效率。6.2.1实战案例：并行化多Agent环境在Coach中，可以使用SubprocVecEnv或DummyVecEnv来并行化环境。这里我们使用SubprocVecEnv，因为它可以在不同的进程中运行环境，从而避免GIL（全局解释器锁）的限制。fromcoach.coreimportSubprocVecEnv

defmake_env():

returnMultiAgentGrid()

envs=[make_envfor_inrange(4)]#创建4个环境实例

vec_env=SubprocVecEnv(envs)

#使用并行环境进行训练

trainer=MultiAgentTrainer(vec_env,agents)

trainer.train()6.3自定义网络结构在强化学习中，智能体的决策过程通常由神经网络模型驱动。Coach提供了灵活的API来定义和使用自定义的神经网络结构。6.3.1实战案例：自定义网络结构假设我们想要创建一个更复杂的网络结构，以处理多Agent环境中的状态和动作。我们可以定义一个自定义的网络类，然后在智能体中使用它。importtorch

importtorch.nnasnn

fromcoach.coreimportAgent

classCustomNetwork(nn.Module):

def__init__(self,input_shape,num_actions):

super(CustomNetwork,self).__init__()

self.fc1=nn.Linear(input_shape[0]*input_shape[1],128)

self.fc2=nn.Linear(128,64)

self.fc3=nn.Linear(64,num_actions)

defforward(self,x):

x=x.view(x.size(0),-1)

x=torch.relu(self.fc1(x))

x=torch.relu(self.fc2(x))

x=self.fc3(x)

returnx

classCustomAgent(Agent):

def__init__(self,env):

super().__init__(env)

work=CustomNetwork(env.observation_space.shape,env.action_space.n)

defact(self,obs,is_test=False):

obs=torch.tensor(obs,dtype=torch.float32)

q_values=work(obs)

ifis_test:

action=torch.argmax(q_values).item()

else:

action=torch.multinomial(torch.softmax(q_values,dim=0),1).item()

returnaction6.3.2结合使用将上述自定义的多Agent环境、并行化环境和自定义网络结构结合，可以创建一个高效的多智能体强化学习系统。agents=[CustomAgent(vec_env)for_inrange(2)]#创建两个智能体

trainer=MultiAgentTrainer(vec_env,agents)

trainer.train()通过上述代码，我们定义了一个多Agent环境，实现了环境的并行化，以及使用自定义的神经网络结构来驱动智能体的决策过程。这为处理更复杂、更现实的多智能体场景提供了基础。7Coach项目实战：自定义环境与Agent7.1项目规划与设计在开始任何强化学习项目之前，规划和设计是至关重要的步骤。这包括定义项目的目标、选择合适的强化学习算法、设计环境和Agent的交互方式，以及确定性能评估标准。7.1.1目标定义假设我们的目标是创建一个Agent，能够在自定义的迷宫环境中找到从起点到终点的最短路径。这个目标不仅要求Agent能够探索环境，还需要它能够学习并优化其策略以达到最佳性能。7.1.2算法选择对于迷宫寻路问题，我们可以选择使用Q-Learning算法，因为它适用于离散动作空间和状态空间的环境，能够通过试错学习找到最优策略。7.1.3环境设计环境需要能够模拟迷宫的布局，包括墙壁、起点和终点。此外，环境还应能够提供Agent当前的位置信息，以及在采取行动后的奖励和新状态。7.1.4Agent设计Agent需要能够接收环境的状态，根据当前状态选择动作，并根据环境反馈的奖励和新状态更新其策略。7.1.5性能评估性能评估可以通过测量Agent找到终点的平均步数，以及在一定数量的尝试后，Agent是否能够稳定地找到最短路径。7.2环境与Agent实现7.2.1环境实现首先，我们需要创建一个迷宫环境。这里使用Python和Coach库来实现。importnumpyasnp

fromcoachimportcore

classMazeEnvironment(core.Environment):

def__init__(self,maze_layout):

self.maze=np.array(maze_layout)

self.start=np.argwhere(self.maze==1)[0]

self.end=np.argwhere(self.maze==2)[0]

self.agent_position=self.start

self.done=False

defreset(self):

self.agent_position=self.start

self.done=False

returnself.agent_position

defstep(self,action):

ifself.done:

returnself.agent_position,0,self.done

ifaction==0:#上

new_position=self.agent_position-[0,1]

elifaction==1:#下

new_position=self.agent_position+[0,1]

elifaction==2:#左

new_position=self.agent_position-[1,0]

elifaction==3:#右

new_position=self.agent_position+[1,0]

ifself._is_valid_move(new_position):

self.agent_position=new_position

ifnp.array_equal(self.agent_position,self.end):

self.done=True

returnself.agent_position,1,self.done

returnself.agent_position,-0.1,self.done

def_is_valid_move(self,position):

ifposition[0]<0orposition[0]>=self.maze.shape[0]:

returnFalse

ifposition[1]<0orposition[1]>=self.maze.shape[1]:

returnFalse

ifself.maze[position[0],position[1]]==0:#墙壁

returnFalse

returnTrue7.2.2Agent实现接下来，我们实现一个使用Q-Learning算法的Agent。fromcoachimportcore

classQLearningAgent(core.Agent):

def__init__(self,environment,learning_rate=0.1,discount_factor=0.9,exploration_rate=1.0,exploration_decay=0.99):

self.env=environment

self.learning_rate=learning_rate

self.discount_factor=discount_factor

self.exploration_rate=exploration_rate

self.exploration_decay=exploration_decay

self.q_table=np.zeros((self.env.maze.shape[0],self.env.maze.shape[1],4))

de