In diesem Tutorial erstellen wir ein fortschrittliches Agenten-Deep-Reinforcement-Studying-System, das einen Agenten dabei anleitet, nicht nur Aktionen innerhalb einer Umgebung zu erlernen, sondern auch, wie er seine eigenen Trainingsstrategien auswählt. Wir entwerfen einen Dueling Double DQN-Lerner, führen einen Lehrplan mit zunehmendem Schwierigkeitsgrad ein und integrieren mehrere Erkundungsmodi, die sich an die Weiterentwicklung des Trainings anpassen. Am wichtigsten ist, dass wir einen Meta-Agenten konstruieren, der den gesamten Lernprozess plant, bewertet und reguliert und es uns ermöglicht, zu erleben, wie die Agentur Reinforcement Studying in einen selbstgesteuerten, strategischen Arbeitsablauf umwandelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
!pip set up -q gymnasium(classic-control) torch matplotlib
import gymnasium as health club
import numpy as np
import torch, torch.nn as nn, torch.optim as optim
from collections import deque, defaultdict
import math, random, matplotlib.pyplot as plt
random.seed(0); np.random.seed(0); torch.manual_seed(0)
class DuelingQNet(nn.Module):
def __init__(self, obs_dim, act_dim):
tremendous().__init__()
hidden = 128
self.characteristic = nn.Sequential(
nn.Linear(obs_dim, hidden),
nn.ReLU(),
)
self.value_head = nn.Sequential(
nn.Linear(hidden, hidden),
nn.ReLU(),
nn.Linear(hidden, 1),
)
self.adv_head = nn.Sequential(
nn.Linear(hidden, hidden),
nn.ReLU(),
nn.Linear(hidden, act_dim),
)
def ahead(self, x):
h = self.characteristic(x)
v = self.value_head(h)
a = self.adv_head(h)
return v + (a - a.imply(dim=1, keepdim=True))
class ReplayBuffer:
def __init__(self, capability=100000):
self.buffer = deque(maxlen=capability)
def push(self, s,a,r,ns,d):
self.buffer.append((s,a,r,ns,d))
def pattern(self, batch_size):
batch = random.pattern(self.buffer, batch_size)
s,a,r,ns,d = zip(*batch)
def to_t(x, dt): return torch.tensor(x, dtype=dt, gadget=gadget)
return to_t(s,torch.float32), to_t(a,torch.lengthy), to_t(r,torch.float32), to_t(ns,torch.float32), to_t(d,torch.float32)
def __len__(self): return len(self.buffer)Wir richten die Kernstruktur unseres Deep-Reinforcement-Studying-Programs ein. Wir initialisieren die Umgebung, erstellen das duellierende Q-Netzwerk und bereiten den Wiedergabepuffer vor, um Übergänge effizient zu speichern. Während wir diese Grundlagen schaffen, bereiten wir alles vor, was unser Agent braucht, um mit dem Lernen zu beginnen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class DQNAgent:
def __init__(self, obs_dim, act_dim, gamma=0.99, lr=1e-3, batch_size=64):
self.q = DuelingQNet(obs_dim, act_dim).to(gadget)
self.tgt = DuelingQNet(obs_dim, act_dim).to(gadget)
self.tgt.load_state_dict(self.q.state_dict())
self.buf = ReplayBuffer()
self.decide = optim.Adam(self.q.parameters(), lr=lr)
self.gamma = gamma
self.batch_size = batch_size
self.global_step = 0
def _eps_value(self, step, begin=1.0, finish=0.05, decay=8000):
return finish + (begin - finish) * math.exp(-step/decay)
def select_action(self, state, mode, technique, softmax_temp=1.0):
s = torch.tensor(state, dtype=torch.float32, gadget=gadget).unsqueeze(0)
with torch.no_grad():
q_vals = self.q(s).cpu().numpy()(0)
if mode == "eval":
return int(np.argmax(q_vals)), None
if technique == "epsilon":
eps = self._eps_value(self.global_step)
if random.random() < eps:
return random.randrange(len(q_vals)), eps
return int(np.argmax(q_vals)), eps
if technique == "softmax":
logits = q_vals / softmax_temp
p = np.exp(logits - np.max(logits))
p /= p.sum()
return int(np.random.selection(len(q_vals), p=p)), None
return int(np.argmax(q_vals)), None
def train_step(self):
if len(self.buf) < self.batch_size:
return None
s,a,r,ns,d = self.buf.pattern(self.batch_size)
with torch.no_grad():
next_q_online = self.q(ns)
next_actions = next_q_online.argmax(dim=1, keepdim=True)
next_q_target = self.tgt(ns).collect(1, next_actions).squeeze(1)
goal = r + self.gamma * next_q_target * (1 - d)
q_vals = self.q(s).collect(1, a.unsqueeze(1)).squeeze(1)
loss = nn.MSELoss()(q_vals, goal)
self.decide.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(self.q.parameters(), 1.0)
self.decide.step()
return float(loss.merchandise())
def update_target(self):
self.tgt.load_state_dict(self.q.state_dict())
def run_episodes(self, env, episodes, mode, technique):
returns = ()
for _ in vary(episodes):
obs,_ = env.reset()
performed = False
ep_ret = 0.0
whereas not performed:
self.global_step += 1
a,_ = self.select_action(obs, mode, technique)
nobs, r, time period, trunc, _ = env.step(a)
performed = time period or trunc
if mode == "practice":
self.buf.push(obs, a, r, nobs, float(performed))
self.train_step()
obs = nobs
ep_ret += r
returns.append(ep_ret)
return float(np.imply(returns))
def evaluate_across_levels(self, ranges, episodes=5):
scores = {}
for title, max_steps in ranges.gadgets():
env = health club.make("CartPole-v1", max_episode_steps=max_steps)
avg = self.run_episodes(env, episodes, mode="eval", technique="epsilon")
env.shut()
scores(title) = avg
return scoresWir definieren, wie unser Agent die Umgebung beobachtet, Aktionen auswählt und sein neuronales Netzwerk aktualisiert. Wir implementieren Double-DQN-Logik, Verlaufsaktualisierungen und Erkundungsstrategien, die es dem Agenten ermöglichen, Lernen und Entdecken in Einklang zu bringen. Nachdem wir dieses Snippet fertiggestellt haben, statten wir unseren Agenten mit seinen vollständigen Low-Degree-Lernfunktionen aus. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class MetaAgent:
def __init__(self, agent):
self.agent = agent
self.ranges = {
"EASY": 100,
"MEDIUM": 300,
"HARD": 500,
}
self.plans = ()
for diff in self.ranges.keys():
for mode in ("practice", "eval"):
for expl in ("epsilon", "softmax"):
self.plans.append((diff, mode, expl))
self.counts = defaultdict(int)
self.values = defaultdict(float)
self.t = 0
self.historical past = ()
def _ucb_score(self, plan, c=2.0):
n = self.counts(plan)
if n == 0:
return float("inf")
return self.values(plan) + c * math.sqrt(math.log(self.t+1) / n)
def select_plan(self):
self.t += 1
scores = (self._ucb_score(p) for p in self.plans)
return self.plans(int(np.argmax(scores)))
def make_env(self, diff):
max_steps = self.ranges(diff)
return health club.make("CartPole-v1", max_episode_steps=max_steps)
def meta_reward_fn(self, diff, mode, avg_return):
r = avg_return
if diff == "MEDIUM": r += 20
if diff == "HARD": r += 50
if mode == "eval" and diff == "HARD": r += 50
return r
def update_plan_value(self, plan, meta_reward):
self.counts(plan) += 1
n = self.counts(plan)
mu = self.values(plan)
self.values(plan) = mu + (meta_reward - mu) / n
def run(self, meta_rounds=30):
eval_log = {"EASY":(), "MEDIUM":(), "HARD":()}
for okay in vary(1, meta_rounds+1):
diff, mode, expl = self.select_plan()
env = self.make_env(diff)
avg_ret = self.agent.run_episodes(env, 5 if mode=="practice" else 3, mode, expl if mode=="practice" else "epsilon")
env.shut()
if okay % 3 == 0:
self.agent.update_target()
meta_r = self.meta_reward_fn(diff, mode, avg_ret)
self.update_plan_value((diff,mode,expl), meta_r)
self.historical past.append((okay, diff, mode, expl, avg_ret, meta_r))
if mode == "eval":
eval_log(diff).append((okay, avg_ret))
print(f"{okay} {diff} {mode} {expl} {avg_ret:.1f} {meta_r:.1f}")
return eval_logWir entwerfen die Agentenschicht, die entscheidet, wie der Agent trainieren soll. Wir verwenden einen UCB-Banditen, um Schwierigkeitsgrade, Modi und Erkundungsstile basierend auf der bisherigen Leistung auszuwählen. Während wir diese Entscheidungen wiederholt treffen, beobachten wir, wie der Metaagent den gesamten Trainingsprozess strategisch steuert. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
tmp_env = health club.make("CartPole-v1", max_episode_steps=100)
obs_dim, act_dim = tmp_env.observation_space.form(0), tmp_env.action_space.n
tmp_env.shut()
agent = DQNAgent(obs_dim, act_dim)
meta = MetaAgent(agent)
eval_log = meta.run(meta_rounds=36)
final_scores = agent.evaluate_across_levels(meta.ranges, episodes=10)
print("Ultimate Analysis")
for okay, v in final_scores.gadgets():
print(okay, v)Wir bringen alles zusammen, indem wir Metarunden starten, in denen der Metaagent Pläne auswählt und der DQN-Agent sie ausführt. Wir verfolgen, wie sich die Leistung entwickelt und wie sich der Agent an immer schwierigere Aufgaben anpasst. Während dieser Ausschnitt läuft, sehen wir die Entstehung eines langfristigen selbstgesteuerten Lernens. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
plt.determine(figsize=(9,4))
for diff, colour in (("EASY","tab:blue"), ("MEDIUM","tab:orange"), ("HARD","tab:pink")):
if eval_log(diff):
x, y = zip(*eval_log(diff))
plt.plot(x, y, marker="o", label=f"{diff}")
plt.xlabel("Meta-Spherical")
plt.ylabel("Avg Return")
plt.title("Agentic Meta-Management Analysis")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.present()Wir visualisieren, wie der Agent im Laufe der Zeit bei einfachen, mittleren und schwierigen Aufgaben abschneidet. Wir beobachten Lerntrends, Verbesserungen und die Auswirkungen der Agentenplanung, die sich in den Kurven widerspiegeln. Wenn wir diese Diagramme analysieren, gewinnen wir Erkenntnisse darüber, wie strategische Entscheidungen den Gesamtfortschritt des Agenten beeinflussen.
Zusammenfassend beobachten wir, wie sich unser Agent zu einem System entwickelt, das auf mehreren Ebenen lernt, seine Richtlinien verfeinert, seine Erkundung anpasst und strategisch auswählt, wie es sich selbst trainiert. Wir beobachten, wie der Meta-Agent seine Entscheidungen durch UCB-basierte Planung verfeinert und den Lernenden auf niedrigem Niveau zu anspruchsvolleren Aufgaben und verbesserter Stabilität führt. Mit einem tieferen Verständnis dafür, wie Agentenstrukturen das verstärkende Lernen verstärken, können wir Systeme erstellen, die ihre eigene Verbesserung im Laufe der Zeit planen, anpassen und optimieren.
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 Publication. 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.