В этом руководстве мы создадим мини-среду для обучения с подкреплением, в которой многоагентная система учится перемещаться по сетке через взаимодействие, обратную связь и многоуровневое принятие решений. Мы создадим всё с нуля и объединим три роли агентов: агент действия, агент инструмента и супервизор, чтобы наблюдать, как простые эвристики, анализ и надзор способствуют более интеллектуальному поведению.
Создание среды GridWorld
Мы настроим всю среду GridWorld и определим, как в ней существуют агент, цель и препятствия. Мы установим структуру для представления состояния и допустимых движений, а также подготовим среду для динамического взаимодействия.
«`python
import numpy as np
import matplotlib.pyplot as plt
from IPython.display import clear_output
import time
from collections import defaultdict
class GridWorld:
def init(self, size=8):
self.size = size
self.agent_pos = [0, 0]
self.goal_pos = [size-1, size-1]
self.obstacles = self.generateobstacles()
self.visited = set()
self.step_count = 0
self.max_steps = size size 2
def generateobstacles(self):
obstacles = set()
n_obstacles = self.size
while len(obstacles) < n_obstacles:
pos = (np.random.randint(1, self.size-1),
np.random.randint(1, self.size-1))
if pos != (0, 0) and pos != (self.size-1, self.size-1):
obstacles.add(pos)
return obstacles
def reset(self):
self.agent_pos = [0, 0]
self.visited = {tuple(self.agent_pos)}
self.step_count = 0
return self.getstate()
def getstate(self):
return {
‘position’: tuple(self.agent_pos),
‘goal’: self.goal_pos,
‘distancetogoal’: abs(self.agentpos[0] — self.goalpos[0]) +
abs(self.agentpos[1] — self.goalpos[1]),
‘visited_count’: len(self.visited),
‘steps’: self.step_count,
‘canmove’: self.getvalidactions()
}
def getvalid_actions(self):
valid = []
moves = {‘up’: [-1, 0], ‘down’: [1, 0], ‘left’: [0, -1], ‘right’: [0, 1]}
for action, delta in moves.items():
newpos = [self.agentpos[0] + delta[0], self.agent_pos[1] + delta[1]]
if (0 <= newpos[0] < self.size and 0 <= newpos[1] < self.size and
tuple(new_pos) not in self.obstacles):
valid.append(action)
return valid
«`
Определение шагов в среде
Мы определяем, как работает каждый шаг в среде и как мир визуализируется. Мы рассчитываем вознаграждения, обнаруживаем столкновения, отслеживаем прогресс и отображаем всё через чёткую визуализацию сетки.
«`python
class GridWorld(GridWorld):
def step(self, action):
self.step_count += 1
moves = {‘up’: [-1, 0], ‘down’: [1, 0], ‘left’: [0, -1], ‘right’: [0, 1]}
if action not in moves:
return self.getstate(), -1, False, «Invalid action»
delta = moves[action]
newpos = [self.agentpos[0] + delta[0], self.agent_pos[1] + delta[1]]
if not (0 <= newpos[0] < self.size and 0 <= newpos[1] < self.size):
return self.getstate(), -1, False, «Hit wall»
if tuple(new_pos) in self.obstacles:
return self.getstate(), -1, False, «Hit obstacle»
self.agentpos = newpos
postuple = tuple(self.agentpos)
reward = -0.1
if pos_tuple not in self.visited:
reward += 0.5
self.visited.add(pos_tuple)
done = False
info = «Moved»
if self.agentpos == self.goalpos:
reward += 10
done = True
info = «Goal reached!»
elif self.stepcount >= self.maxsteps:
done = True
info = «Max steps reached»
return self.getstate(), reward, done, info
def render(self, agent_thoughts=None):
grid = np.zeros((self.size, self.size, 3))
for pos in self.visited:
grid[pos[0], pos[1]] = [0.7, 0.9, 1.0]
for obs in self.obstacles:
grid[obs[0], obs[1]] = [0.2, 0.2, 0.2]
grid[self.goalpos[0], self.goalpos[1]] = [0, 1, 0]
grid[self.agentpos[0], self.agentpos[1]] = [1, 0, 0]
plt.figure(figsize=(10, 8))
plt.imshow(grid, interpolation=’nearest’)
plt.title(f»Step: {self.step_count} | Visited: {len(self.visited)}/{self.size*self.size}»)
for i in range(self.size + 1):
plt.axhline(i — 0.5, color=’gray’, linewidth=0.5)
plt.axvline(i — 0.5, color=’gray’, linewidth=0.5)
if agent_thoughts:
plt.text(0.5, -1.5, agent_thoughts, ha=’center’, fontsize=9,
bbox=dict(boxstyle=’round’, facecolor=’wheat’, alpha=0.8),
wrap=True, transform=plt.gca().transData)
plt.axis(‘off’)
plt.tight_layout()
plt.show()
«`
Реализация агентов
Мы реализуем агента действия и агента инструмента, давая системе возможность обучения и аналитическую обратную связь. Мы наблюдаем, как агент действия выбирает действия через баланс между исследованием и эксплуатацией, в то время как агент инструмента оценивает производительность и предлагает улучшения. Вместе они создают цикл обучения, который развивается с опытом.
«`python
class ActionAgent:
def init(self):
self.q_values = defaultdict(lambda: defaultdict(float))
self.epsilon = 0.3
self.learning_rate = 0.1
self.discount = 0.95
def choose_action(self, state):
validactions = state[‘canmove’]
if not valid_actions:
return None
pos = state[‘position’]
if np.random.random() < self.epsilon:
action = np.random.choice(valid_actions)
reasoning = f»Exploring randomly: chose ‘{action}'»
else:
actionvalues = {a: self.qvalues[pos][a] for a in valid_actions}
action = max(actionvalues, key=actionvalues.get)
reasoning = f»Exploiting: chose ‘{action}’ (Q={self.q_values[pos][action]:.2f})»
return action, reasoning
def learn(self, state, action, reward, next_state):
pos = state[‘position’]
nextpos = nextstate[‘position’]
currentq = self.qvalues[pos][action]
nextmaxq = max([self.qvalues[nextpos][a] for a in nextstate[‘canmove’]], default=0)
newq = currentq + self.learning_rate * (
reward + self.discount * nextmaxq — current_q)
self.qvalues[pos][action] = newq
class ToolAgent:
def analyze(self, state, action_taken, reward, history):
suggestions = []
distance = state[‘distancetogoal’]
if distance <= 3:
suggestions.append(» Very close to goal! Prioritize direct path.»)
explorationrate = state[‘visitedcount’] / (state[‘steps’] + 1)
if exploration_rate < 0.5 and distance > 5:
suggestions.append(» Low exploration rate. Consider exploring more.»)
if len(history) >= 5:
recent_rewards = [h[2] for h in history[-5:]]
avgreward = np.mean(recentrewards)
if avg_reward < -0.5:
suggestions.append(» Negative reward trend. Try different strategy.»)
elif avg_reward > 0.3:
suggestions.append(» Good progress! Current strategy working.»)
if len(state[‘can_move’]) <= 2:
suggestions.append(» Limited movement options. Be careful.»)
return suggestions
«`
Введение супервизора
Мы вводим супервизора, который действует как окончательное лицо, принимающее решения в системе. Мы видим, как он интерпретирует предложения, отменяет рискованные выборы и обеспечивает соответствие действий общим целям.
«`python
class SupervisorAgent:
def decide(self, state, proposedaction, toolsuggestions):
if not proposed_action:
return None, «No valid actions available»
decision = proposed_action
reasoning = f»Approved action ‘{proposed_action}'»
for suggestion in tool_suggestions:
if «goal» in suggestion.lower() and «close» in suggestion.lower():
goaldirection = self.getgoaldirection(state)
if goaldirection in state[‘canmove’]:
decision = goal_direction
reasoning = f»Override: Moving ‘{goal_direction}’ toward goal»
break
return decision, reasoning
def getgoal_direction(self, state):
pos = state[‘position’]
goal = state[‘goal’]
if goal[0] > pos[0]:
return ‘down’
elif goal[0] < pos[0]:
return ‘up’
elif goal[1] > pos[1]:
return ‘right’
else:
return ‘left’
«`
Обучение многоагентной системы
Мы запускаем полный цикл обучения, где все агенты сотрудничают внутри среды в течение нескольких эпизодов. Мы отслеживаем вознаграждения, наблюдаем за моделями движения и визуализируем прогресс обучения с каждым испытанием.
«`python
def trainmultiagent(episodes=5, visualize=True):
env = GridWorld(size=8)
action_agent = ActionAgent()
tool_agent = ToolAgent()
supervisor = SupervisorAgent()
episode_rewards = []
episode_steps = []
for episode in range(episodes):
state = env.reset()
total_reward = 0
done = False
history = []
print(f»\n{‘=’*60}»)
print(f»EPISODE {episode + 1}/{episodes}»)
print(f»{‘=’*60}»)
while not done:
actionresult = actionagent.choose_action(state)
if action_result is None:
break
proposedaction, actionreasoning = action_result
suggestions = toolagent.analyze(state, proposedaction, total_reward, history)
finalaction, supervisorreasoning = supervisor.decide(state, proposed_action, suggestions)
if final_action is None:
break
nextstate, reward, done, info = env.step(finalaction)
total_reward += reward
actionagent.learn(state, finalaction, reward, next_state)
history.append((state, finalaction, reward, nextstate))
if visualize:
clear_output(wait=True)
thoughts = (f»Action Agent: {action_reasoning}\n»
f»Supervisor: {supervisor_reasoning}\n»
f»Tool Agent: {‘, ‘.join(suggestions[:2]) if suggestions else ‘No suggestions’}\n»
f»Reward: {reward:.2f} | Total: {total_reward:.2f}»)
env.render(thoughts)
time.sleep(0.3)
state = next_state
episoderewards.append(totalreward)
episodesteps.append(env.stepcount)
print(f»\nEpisode {episode+1} Complete!»)
print(f»Total Reward: {total_reward:.2f}»)
print(f»Steps Taken: {env.step_count}»)
print(f»Cells Visited: {len(env.visited)}/{env.size2}»)
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(episode_rewards, marker=’o’)
plt.title(‘Episode Rewards’)
plt.xlabel(‘Episode’)
plt.ylabel(‘Total Reward’)
plt.grid(True, alpha=0.3)
plt.subplot(1, 2, 2)
plt.plot(episode_steps, marker=’s’, color=’orange’)
plt.title(‘Episode Steps’)
plt.xlabel(‘Episode’)
plt.ylabel(‘Steps to Complete’)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
return actionagent, toolagent, supervisor
if name == «main«:
print(» Multi-Agent RL System: Grid World Navigation»)
print(«=» * 60)
print(«Components:»)
print(» • Action Agent: Proposes actions using Q-learning»)
print(» • Tool Agent: Analyzes performance and suggests improvements»)
print(» • Supervisor Agent: Makes final decisions»)
print(«=» * 60)
trainedagents = trainmulti_agent(episodes=5, visualize=True)
«`
В этом руководстве мы видим, как многоагентная система RL возникает из чистых компонентов и как каждый слой способствует более умному перемещению по сетке: агент действия учится через Q-обновления, агент инструмента направляет улучшения, а супервизор обеспечивает безопасный выбор действий, ориентированных на достижение цели.
1. Какие роли выполняют агенты в созданной мини-среде для обучения с подкреплением и как они взаимодействуют между собой?
Ответ: в созданной мини-среде для обучения с подкреплением определены три роли агентов: агент действия, агент инструмента и супервизор. Агент действия выбирает действия через баланс между исследованием и эксплуатацией, используя Q-обучение. Агент инструмента оценивает производительность и предлагает улучшения. Супервизор интерпретирует предложения, отменяет рискованные выборы и обеспечивает соответствие действий общим целям. Взаимодействие между агентами создаёт цикл обучения, который развивается с опытом.
2. Какие методы используются для обучения агента действия в среде GridWorld?
Ответ: агент действия в среде GridWorld обучается с помощью метода Q-обучения. Он выбирает действия на основе баланса между исследованием и эксплуатацией, а затем обновляет свои Q-значения на основе полученного вознаграждения и прогноза будущих наград.
3. Какие функции выполняет агент инструмента в созданной многоагентной системе и как он влияет на процесс обучения?
Ответ: агент инструмента в созданной многоагентной системе анализирует производительность агента действия и предлагает улучшения. Он может предложить изменить стратегию, если агент действия не достигает цели, или предложить исследовать больше, если агент действия не исследует достаточно. Это влияет на процесс обучения, так как агент действия может использовать предложения агента инструмента для улучшения своей стратегии и достижения цели.
4. Какие параметры используются для настройки поведения агента действия в среде GridWorld и как они влияют на его обучение?
Ответ: для настройки поведения агента действия в среде GridWorld используются следующие параметры: epsilon (ε), learning rate (α) и discount factor (γ). Epsilon определяет вероятность выбора случайного действия для исследования, learning rate определяет скорость обучения агента, а discount factor определяет важность будущих наград по сравнению с текущими. Эти параметры влияют на обучение агента действия, определяя его стратегию выбора действий и скорость сходимости к оптимальной стратегии.
5. Как супервизор влияет на принятие решений в многоагентной системе и какие цели он преследует?
Ответ: супервизор в многоагентной системе действует как окончательное лицо, принимающее решения. Он интерпретирует предложения агента инструмента, отменяет рискованные выборы и обеспечивает соответствие действий общим целям. Цели супервизора включают обеспечение безопасности и эффективности действий агента действия, а также достижение цели в среде GridWorld.