In diesem Tutorial untersuchen wir, wie ein intelligenter Agent schrittweise ein prozedurales Gedächtnis aufbauen kann, indem er wiederverwendbare Fähigkeiten direkt aus seinen Interaktionen mit einer Umgebung erlernt. Wir entwerfen ein minimales, aber leistungsstarkes Framework, in dem sich Fähigkeiten wie neuronale Module verhalten: Sie speichern Aktionssequenzen, tragen kontextuelle Einbettungen und werden durch Ähnlichkeit abgerufen, wenn eine neue Scenario einer Erfahrung ähnelt. Während wir unseren Agenten durch mehrere Episoden führen, beobachten wir, wie sein Verhalten effizienter wird und von der primitiven Erkundung zur Nutzung einer Bibliothek von Fähigkeiten übergeht, die er selbstständig erlernt hat. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
import numpy as np
import matplotlib.pyplot as plt
from collections import defaultdict
class Talent:
def __init__(self, title, preconditions, action_sequence, embedding, success_count=0):
self.title = title
self.preconditions = preconditions
self.action_sequence = action_sequence
self.embedding = embedding
self.success_count = success_count
self.times_used = 0
def is_applicable(self, state):
for key, worth in self.preconditions.gadgets():
if state.get(key) != worth:
return False
return True
def __repr__(self):
return f"Talent({self.title}, used={self.times_used}, success={self.success_count})"
class SkillLibrary:
def __init__(self, embedding_dim=8):
self.abilities = ()
self.embedding_dim = embedding_dim
self.skill_stats = defaultdict(lambda: {"makes an attempt": 0, "successes": 0})
def add_skill(self, ability):
for existing_skill in self.abilities:
if self._similarity(ability.embedding, existing_skill.embedding) > 0.9:
existing_skill.success_count += 1
return existing_skill
self.abilities.append(ability)
return ability
def retrieve_skills(self, state, query_embedding=None, top_k=3):
relevant = (s for s in self.abilities if s.is_applicable(state))
if query_embedding shouldn't be None and relevant:
similarities = (self._similarity(query_embedding, s.embedding) for s in relevant)
sorted_skills = (s for _, s in sorted(zip(similarities, relevant), reverse=True))
return sorted_skills(:top_k)
return sorted(relevant, key=lambda s: s.success_count / max(s.times_used, 1), reverse=True)(:top_k)
def _similarity(self, emb1, emb2):
return np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2) + 1e-8)
def get_stats(self):
return {
"total_skills": len(self.abilities),
"total_uses": sum(s.times_used for s in self.abilities),
"avg_success_rate": np.imply((s.success_count / max(s.times_used, 1) for s in self.abilities)) if self.abilities else 0
}Wir definieren, wie Fähigkeiten in einer Gedächtnisstruktur dargestellt und gespeichert werden. Wir implementieren einen auf Ähnlichkeit basierenden Abruf, damit der Agent mithilfe der Kosinusähnlichkeit einen neuen Zustand mit früheren Fähigkeiten abgleichen kann. Während wir diese Ebene durcharbeiten, sehen wir, wie die Wiederverwendung von Fertigkeiten möglich wird, sobald Fertigkeiten Metadaten, Einbettungen und Nutzungsstatistiken erwerben. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class GridWorld:
def __init__(self, dimension=5):
self.dimension = dimension
self.reset()
def reset(self):
self.agent_pos = (0, 0)
self.goal_pos = (self.size-1, self.size-1)
self.objects = {"key": (2, 2), "door": (3, 3), "field": (1, 3)}
self.stock = ()
self.door_open = False
return self.get_state()
def get_state(self):
return {
"agent_pos": tuple(self.agent_pos),
"has_key": "key" in self.stock,
"door_open": self.door_open,
"at_goal": self.agent_pos == self.goal_pos,
"objects": {ok: tuple(v) for ok, v in self.objects.gadgets()}
}
def step(self, motion):
reward = -0.1
if motion == "move_up":
self.agent_pos(1) = min(self.agent_pos(1) + 1, self.dimension - 1)
elif motion == "move_down":
self.agent_pos(1) = max(self.agent_pos(1) - 1, 0)
elif motion == "move_left":
self.agent_pos(0) = max(self.agent_pos(0) - 1, 0)
elif motion == "move_right":
self.agent_pos(0) = min(self.agent_pos(0) + 1, self.dimension - 1)
elif motion == "pickup_key":
if self.agent_pos == self.objects("key") and "key" not in self.stock:
self.stock.append("key")
reward = 1.0
elif motion == "open_door":
if self.agent_pos == self.objects("door") and "key" in self.stock:
self.door_open = True
reward = 2.0
performed = self.agent_pos == self.goal_pos and self.door_open
if performed:
reward = 10.0
return self.get_state(), reward, performedWir konstruieren eine einfache Umgebung, in der der Agent Aufgaben wie das Aufheben eines Schlüssels, das Öffnen einer Tür und das Erreichen eines Ziels lernt. Wir nutzen diese Umgebung als Spielplatz für unser prozedurales Gedächtnissystem und können so beobachten, wie sich primitive Handlungen zu komplexeren, wiederverwendbaren Fähigkeiten entwickeln. Die Struktur der Umgebung hilft uns, klare, interpretierbare Verhaltensverbesserungen über Episoden hinweg zu beobachten. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class ProceduralMemoryAgent:
def __init__(self, env, embedding_dim=8):
self.env = env
self.skill_library = SkillLibrary(embedding_dim)
self.embedding_dim = embedding_dim
self.episode_history = ()
self.primitive_actions = ("move_up", "move_down", "move_left", "move_right", "pickup_key", "open_door")
def create_embedding(self, state, action_seq):
state_vec = np.zeros(self.embedding_dim)
state_vec(0) = hash(str(state("agent_pos"))) % 1000 / 1000
state_vec(1) = 1.0 if state.get("has_key") else 0.0
state_vec(2) = 1.0 if state.get("door_open") else 0.0
for i, motion in enumerate(action_seq(:self.embedding_dim-3)):
state_vec(3+i) = hash(motion) % 1000 / 1000
return state_vec / (np.linalg.norm(state_vec) + 1e-8)
def extract_skill(self, trajectory):
if len(trajectory) < 2:
return None
start_state = trajectory(0)(0)
actions = (a for _, a, _ in trajectory)
preconditions = {"has_key": start_state.get("has_key", False), "door_open": start_state.get("door_open", False)}
end_state = self.env.get_state()
if end_state.get("has_key") and never start_state.get("has_key"):
title = "acquire_key"
elif end_state.get("door_open") and never start_state.get("door_open"):
title = "open_door_sequence"
else:
title = f"navigate_{len(actions)}_steps"
embedding = self.create_embedding(start_state, actions)
return Talent(title, preconditions, actions, embedding, success_count=1)
def execute_skill(self, ability):
ability.times_used += 1
trajectory = ()
total_reward = 0
for motion in ability.action_sequence:
state = self.env.get_state()
next_state, reward, performed = self.env.step(motion)
trajectory.append((state, motion, reward))
total_reward += reward
if performed:
ability.success_count += 1
return trajectory, total_reward, True
return trajectory, total_reward, False
def discover(self, max_steps=20):
trajectory = ()
state = self.env.get_state()
for _ in vary(max_steps):
motion = self._choose_exploration_action(state)
next_state, reward, performed = self.env.step(motion)
trajectory.append((state, motion, reward))
state = next_state
if performed:
return trajectory, True
return trajectory, FalseWir konzentrieren uns auf die Erstellung von Einbettungen, die den Kontext einer Zustands-Aktionssequenz kodieren und es uns ermöglichen, Fähigkeiten sinnvoll zu vergleichen. Wir extrahieren auch Fähigkeiten aus erfolgreichen Entwicklungen und wandeln rohe Erfahrungen in wiederverwendbare Verhaltensweisen um. Während wir diesen Code ausführen, beobachten wir, wie durch einfache Erkundung nach und nach strukturiertes Wissen entsteht, das der Agent später anwenden kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def _choose_exploration_action(self, state):
agent_pos = state("agent_pos")
if not state.get("has_key"):
key_pos = state("objects")("key")
if agent_pos == key_pos:
return "pickup_key"
if agent_pos(0) < key_pos(0):
return "move_right"
if agent_pos(0) > key_pos(0):
return "move_left"
if agent_pos(1) < key_pos(1):
return "move_up"
return "move_down"
if state.get("has_key") and never state.get("door_open"):
door_pos = state("objects")("door")
if agent_pos == door_pos:
return "open_door"
if agent_pos(0) < door_pos(0):
return "move_right"
if agent_pos(0) > door_pos(0):
return "move_left"
if agent_pos(1) < door_pos(1):
return "move_up"
return "move_down"
goal_pos = (4, 4)
if agent_pos(0) < goal_pos(0):
return "move_right"
if agent_pos(1) < goal_pos(1):
return "move_up"
return np.random.alternative(self.primitive_actions)
def run_episode(self, use_skills=True):
self.env.reset()
total_reward = 0
steps = 0
trajectory = ()
whereas steps < 50:
state = self.env.get_state()
if use_skills and self.skill_library.abilities:
query_emb = self.create_embedding(state, ())
abilities = self.skill_library.retrieve_skills(state, query_emb, top_k=1)
if abilities:
skill_traj, skill_reward, success = self.execute_skill(abilities(0))
trajectory.lengthen(skill_traj)
total_reward += skill_reward
steps += len(skill_traj)
if success:
return trajectory, total_reward, steps, True
proceed
motion = self._choose_exploration_action(state)
next_state, reward, performed = self.env.step(motion)
trajectory.append((state, motion, reward))
total_reward += reward
steps += 1
if performed:
return trajectory, total_reward, steps, True
return trajectory, total_reward, steps, False
def prepare(self, episodes=10):
stats = {"rewards": (), "steps": (), "skills_learned": (), "skill_uses": ()}
for ep in vary(episodes):
trajectory, reward, steps, success = self.run_episode(use_skills=True)
if success and len(trajectory) >= 3:
phase = trajectory(-min(5, len(trajectory)):)
ability = self.extract_skill(phase)
if ability:
self.skill_library.add_skill(ability)
stats("rewards").append(reward)
stats("steps").append(steps)
stats("skills_learned").append(len(self.skill_library.abilities))
stats("skill_uses").append(self.skill_library.get_stats()("total_uses"))
print(f"Episode {ep+1}: Reward={reward:.1f}, Steps={steps}, Expertise={len(self.skill_library.abilities)}, Success={success}")
return statsWir definieren, wie der Agent zwischen der Nutzung bekannter Fähigkeiten und der Erkundung mit primitiven Aktionen wählt. Wir schulen den Agenten über mehrere Episoden hinweg und zeichnen die Entwicklung der erlernten Fähigkeiten, Nutzungszahlen und Erfolgsquoten auf. Bei der Untersuchung dieses Teils stellen wir fest, dass die Wiederverwendung von Fertigkeiten die Episodenlänge verkürzt und die Gesamtbelohnungen verbessert. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def visualize_training(stats):
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes(0, 0).plot(stats("rewards"))
axes(0, 0).set_title("Episode Rewards")
axes(0, 1).plot(stats("steps"))
axes(0, 1).set_title("Steps per Episode")
axes(1, 0).plot(stats("skills_learned"))
axes(1, 0).set_title("Expertise in Library")
axes(1, 1).plot(stats("skill_uses"))
axes(1, 1).set_title("Cumulative Talent Makes use of")
plt.tight_layout()
plt.savefig("skill_learning_stats.png", dpi=150, bbox_inches="tight")
plt.present()
if __name__ == "__main__":
print("=== Procedural Reminiscence Agent Demo ===n")
env = GridWorld(dimension=5)
agent = ProceduralMemoryAgent(env)
print("Coaching agent to be taught reusable abilities...n")
stats = agent.prepare(episodes=15)
print("n=== Realized Expertise ===")
for ability in agent.skill_library.abilities:
print(f"{ability.title}: {len(ability.action_sequence)} actions, used {ability.times_used} instances, {ability.success_count} successes")
lib_stats = agent.skill_library.get_stats()
print(f"n=== Library Statistics ===")
print(f"Whole abilities: {lib_stats('total_skills')}")
print(f"Whole ability makes use of: {lib_stats('total_uses')}")
print(f"Avg success fee: {lib_stats('avg_success_rate'):.2%}")
visualize_training(stats)
print("n✓ Talent studying full! Examine the visualization above.")Wir bringen alles zusammen, indem wir Schulungen durchführen, erlernte Fertigkeiten ausdrucken und Verhaltensstatistiken erstellen. Wir visualisieren den Development bei den Belohnungen und wie die Fertigkeitsbibliothek im Laufe der Zeit wächst. Indem wir dieses Snippet ausführen, schließen wir den Lebenszyklus der prozeduralen Gedächtnisbildung ab und bestätigen, dass der Agent lernt, sich mit Erfahrung intelligenter zu verhalten.
Zusammenfassend sehen wir, wie das prozedurale Gedächtnis auf natürliche Weise entsteht, wenn ein Agent lernt, Fähigkeiten aus seinen eigenen erfolgreichen Trajektorien zu extrahieren. Wir beobachten, wie Fähigkeiten erworben werden, Struktur, Metadaten, Einbettungen und Nutzungsmuster, damit der Agent sie in zukünftigen Situationen effizient wiederverwenden kann. Schließlich wissen wir zu schätzen, dass selbst eine kleine Umgebung und einfache Heuristiken zu sinnvollen Lerndynamiken führen und uns ein konkretes Verständnis dafür vermitteln, was es für einen Agenten bedeutet, im Laufe der Zeit wiederverwendbare interne Kompetenzen zu entwickeln.
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.