In diesem Tutorial programmieren wir ein Mini-Setup für verstärktes Lernen, in dem ein Multi-Agenten-System lernt, durch Interaktion, Suggestions und mehrschichtige Entscheidungsfindung in einer Grid-Welt zu navigieren. Wir bauen alles von Grund auf auf und vereinen drei Agentenrollen: einen Aktionsagenten, einen Werkzeugagenten und einen Supervisor, damit wir beobachten können, wie einfache Heuristiken, Analysen und Aufsicht zusammen zu intelligenterem Verhalten führen. Außerdem beobachten wir, wie die Agenten zusammenarbeiten, ihre Strategien verfeinern und nach und nach lernen, das Ziel zu erreichen und dabei Hindernisse und Unsicherheiten zu überwinden. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
import numpy as np
import matplotlib.pyplot as plt
from IPython.show import clear_output
import time
from collections import defaultdict
class GridWorld:
def __init__(self, measurement=8):
self.measurement = measurement
self.agent_pos = (0, 0)
self.goal_pos = (size-1, size-1)
self.obstacles = self._generate_obstacles()
self.visited = set()
self.step_count = 0
self.max_steps = measurement * measurement * 2
def _generate_obstacles(self):
obstacles = set()
n_obstacles = self.measurement
whereas 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._get_state()
def _get_state(self):
return {
'place': tuple(self.agent_pos),
'objective': self.goal_pos,
'distance_to_goal': abs(self.agent_pos(0) - self.goal_pos(0)) +
abs(self.agent_pos(1) - self.goal_pos(1)),
'visited_count': len(self.visited),
'steps': self.step_count,
'can_move': self._get_valid_actions()
}
def _get_valid_actions(self):
legitimate = ()
strikes = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'proper': (0, 1)}
for motion, delta in strikes.gadgets():
new_pos = (self.agent_pos(0) + delta(0), self.agent_pos(1) + delta(1))
if (0 <= new_pos(0) < self.measurement and 0 <= new_pos(1) < self.measurement and
tuple(new_pos) not in self.obstacles):
legitimate.append(motion)
return legitimateWir richten die gesamte GridWorld-Umgebung ein und definieren, wie der Agent, das Ziel und die Hindernisse darin existieren. Wir schaffen die Struktur für die staatliche Repräsentation und gültige Bewegungen und bereiten die Umgebung vor, damit wir dynamisch mit ihr interagieren können. Während wir diesen Teil abarbeiten, sehen wir, wie die Welt Gestalt annimmt und für die Erkundung durch die Agenten bereit ist. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class GridWorld(GridWorld):
def step(self, motion):
self.step_count += 1
strikes = {'up': (-1, 0), 'down': (1, 0), 'left': (0, -1), 'proper': (0, 1)}
if motion not in strikes:
return self._get_state(), -1, False, "Invalid motion"
delta = strikes(motion)
new_pos = (self.agent_pos(0) + delta(0), self.agent_pos(1) + delta(1))
if not (0 <= new_pos(0) < self.measurement and 0 <= new_pos(1) < self.measurement):
return self._get_state(), -1, False, "Hit wall"
if tuple(new_pos) in self.obstacles:
return self._get_state(), -1, False, "Hit impediment"
self.agent_pos = new_pos
pos_tuple = tuple(self.agent_pos)
reward = -0.1
if pos_tuple not in self.visited:
reward += 0.5
self.visited.add(pos_tuple)
performed = False
information = "Moved"
if self.agent_pos == self.goal_pos:
reward += 10
performed = True
information = "Aim reached!"
elif self.step_count >= self.max_steps:
performed = True
information = "Max steps reached"
return self._get_state(), reward, performed, information
def render(self, agent_thoughts=None):
grid = np.zeros((self.measurement, self.measurement, 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.goal_pos(0), self.goal_pos(1)) = (0, 1, 0)
grid(self.agent_pos(0), self.agent_pos(1)) = (1, 0, 0)
plt.determine(figsize=(10, 8))
plt.imshow(grid, interpolation='nearest')
plt.title(f"Step: {self.step_count} | Visited: {len(self.visited)}/{self.measurement*self.measurement}")
for i in vary(self.measurement + 1):
plt.axhline(i - 0.5, colour="grey", linewidth=0.5)
plt.axvline(i - 0.5, colour="grey", linewidth=0.5)
if agent_thoughts:
plt.textual content(0.5, -1.5, agent_thoughts, ha="heart", fontsize=9,
bbox=dict(boxstyle="spherical", facecolor="wheat", alpha=0.8),
wrap=True, remodel=plt.gca().transData)
plt.axis('off')
plt.tight_layout()
plt.present()Wir definieren, wie jeder Schritt in der Umgebung funktioniert und wie die Welt visuell dargestellt wird. Wir berechnen Belohnungen, erkennen Kollisionen, verfolgen den Fortschritt und zeigen alles durch eine übersichtliche Rastervisualisierung an. Während wir diese Logik umsetzen, beobachten wir die Reise des Agenten in Echtzeit mit klarem Suggestions. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class ActionAgent:
def __init__(self):
self.q_values = defaultdict(lambda: defaultdict(float))
self.epsilon = 0.3
self.learning_rate = 0.1
self.low cost = 0.95
def choose_action(self, state):
valid_actions = state('can_move')
if not valid_actions:
return None
pos = state('place')
if np.random.random() < self.epsilon:
motion = np.random.alternative(valid_actions)
reasoning = f"Exploring randomly: selected '{motion}'"
else:
action_values = {a: self.q_values(pos)(a) for a in valid_actions}
motion = max(action_values, key=action_values.get)
reasoning = f"Exploiting: selected '{motion}' (Q={self.q_values(pos)(motion):.2f})"
return motion, reasoning
def be taught(self, state, motion, reward, next_state):
pos = state('place')
next_pos = next_state('place')
current_q = self.q_values(pos)(motion)
next_max_q = max((self.q_values(next_pos)(a) for a in next_state('can_move')), default=0)
new_q = current_q + self.learning_rate * (
reward + self.low cost * next_max_q - current_q)
self.q_values(pos)(motion) = new_q
class ToolAgent:
def analyze(self, state, action_taken, reward, historical past):
options = ()
distance = state('distance_to_goal')
if distance <= 3:
options.append("🎯 Very near objective! Prioritize direct path.")
exploration_rate = state('visited_count') / (state('steps') + 1)
if exploration_rate < 0.5 and distance > 5:
options.append("🔍 Low exploration fee. Take into account exploring extra.")
if len(historical past) >= 5:
recent_rewards = (h(2) for h in historical past(-5:))
avg_reward = np.imply(recent_rewards)
if avg_reward < -0.5:
options.append("⚠️ Detrimental reward development. Attempt completely different technique.")
elif avg_reward > 0.3:
options.append("✅ Good progress! Present technique working.")
if len(state('can_move')) <= 2:
options.append("🚧 Restricted motion choices. Watch out.")
return optionsWir implementieren den Motion Agent und Device Agent und verleihen dem System sowohl Lernfähigkeit als auch analytisches Suggestions. Wir beobachten, wie der Motion Agent Aktionen durch ein ausgewogenes Verhältnis von Exploration und Exploitation auswählt, während der Device Agent die Leistung bewertet und Verbesserungen vorschlägt. Gemeinsam bilden sie eine Lernschleife, die sich mit der Erfahrung weiterentwickelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class SupervisorAgent:
def resolve(self, state, proposed_action, tool_suggestions):
if not proposed_action:
return None, "No legitimate actions accessible"
choice = proposed_action
reasoning = f"Authorized motion '{proposed_action}'"
for suggestion in tool_suggestions:
if "objective" in suggestion.decrease() and "shut" in suggestion.decrease():
goal_direction = self._get_goal_direction(state)
if goal_direction in state('can_move'):
choice = goal_direction
reasoning = f"Override: Transferring '{goal_direction}' towards objective"
break
return choice, reasoning
def _get_goal_direction(self, state):
pos = state('place')
objective = state('objective')
if objective(0) > pos(0):
return 'down'
elif objective(0) < pos(0):
return 'up'
elif objective(1) > pos(1):
return 'proper'
else:
return 'left'Wir stellen den Supervisor Agent vor, der als letzter Entscheidungsträger im System fungiert. Wir sehen, wie es Vorschläge interpretiert, riskante Entscheidungen außer Kraft setzt und sicherstellt, dass die Maßnahmen mit den Gesamtzielen im Einklang bleiben. Wenn wir diese Komponente verwenden, erleben wir einen koordinierten Entscheidungsfluss mit mehreren Agenten. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def train_multi_agent(episodes=5, visualize=True):
env = GridWorld(measurement=8)
action_agent = ActionAgent()
tool_agent = ToolAgent()
supervisor = SupervisorAgent()
episode_rewards = ()
episode_steps = ()
for episode in vary(episodes):
state = env.reset()
total_reward = 0
performed = False
historical past = ()
print(f"n{'='*60}")
print(f"EPISODE {episode + 1}/{episodes}")
print(f"{'='*60}")
whereas not performed:
action_result = action_agent.choose_action(state)
if action_result is None:
break
proposed_action, action_reasoning = action_result
options = tool_agent.analyze(state, proposed_action, total_reward, historical past)
final_action, supervisor_reasoning = supervisor.resolve(state, proposed_action, options)
if final_action is None:
break
next_state, reward, performed, information = env.step(final_action)
total_reward += reward
action_agent.be taught(state, final_action, reward, next_state)
historical past.append((state, final_action, reward, next_state))
if visualize:
clear_output(wait=True)
ideas = (f"Motion Agent: {action_reasoning}n"
f"Supervisor: {supervisor_reasoning}n"
f"Device Agent: {', '.be a part of(options(:2)) if options else 'No options'}n"
f"Reward: {reward:.2f} | Complete: {total_reward:.2f}")
env.render(ideas)
time.sleep(0.3)
state = next_state
episode_rewards.append(total_reward)
episode_steps.append(env.step_count)
print(f"nEpisode {episode+1} Full!")
print(f"Complete Reward: {total_reward:.2f}")
print(f"Steps Taken: {env.step_count}")
print(f"Cells Visited: {len(env.visited)}/{env.measurement**2}")
plt.determine(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(episode_rewards, marker="o")
plt.title('Episode Rewards')
plt.xlabel('Episode')
plt.ylabel('Complete Reward')
plt.grid(True, alpha=0.3)
plt.subplot(1, 2, 2)
plt.plot(episode_steps, marker="s", colour="orange")
plt.title('Episode Steps')
plt.xlabel('Episode')
plt.ylabel('Steps to Full')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.present()
return action_agent, tool_agent, supervisor
if __name__ == "__main__":
print("🤖 Multi-Agent RL System: Grid World Navigation")
print("=" * 60)
print("Parts:")
print(" • Motion Agent: Proposes actions utilizing Q-learning")
print(" • Device Agent: Analyzes efficiency and suggests enhancements")
print(" • Supervisor Agent: Makes last selections")
print("=" * 60)
trained_agents = train_multi_agent(episodes=5, visualize=True)Wir führen die gesamte Trainingsschleife durch, in der alle Agenten über mehrere Episoden hinweg innerhalb der Umgebung zusammenarbeiten. Wir verfolgen Belohnungen, beobachten Bewegungsmuster und visualisieren den Lernfortschritt bei jedem Versuch. Wenn wir diese Schleife abschließen, sehen wir, dass sich das Multi-Agenten-System verbessert und effizienter in der Grid-Welt navigiert.
Abschließend sehen wir, wie aus sauberen Komponenten ein Multi-Agenten-RL-System entsteht und wie jede Schicht zu einer intelligenteren Navigation beiträgt: Der Motion Agent lernt über Q-Updates, der Device Agent leitet Verbesserungen an und der Supervisor sorgt für eine sichere, zielorientierte Aktionsauswahl. Wir wissen zu schätzen, wie diese einfache, aber dynamische Rasterwelt uns dabei hilft, Lernen, Erkunden und Entscheidungsfindung in Echtzeit zu visualisieren.
Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.
Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.