In diesem Tutorial untersuchen wir, wie man Agentensysteme aufbaut, die über eine einzelne Interaktion hinausdenken, indem Speicher als Kernfunktion genutzt wird. Wir gehen durch, wie wir das episodische Gedächtnis zum Speichern von Erfahrungen und das semantische Gedächtnis zum Erfassen langfristiger Muster entwerfen, sodass der Agent sein Verhalten über mehrere Sitzungen hinweg weiterentwickeln kann. Während wir planen, handeln, überarbeiten und reflektieren, beobachten wir, wie sich der Agent allmählich an die Präferenzen des Benutzers anpasst und autonomer wird. Am Ende verstehen wir, wie gedächtnisgesteuertes Denken uns hilft, Agenten zu schaffen, die sich bei jeder Interaktion kontextbezogener, konsistenter und intelligenter anfühlen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
import numpy as np
from collections import defaultdict
import json
from datetime import datetime
import pickle
class EpisodicMemory:
def __init__(self, capability=100):
self.capability = capability
self.episodes = ()
def retailer(self, state, motion, consequence, timestamp=None):
if timestamp is None:
timestamp = datetime.now().isoformat()
episode = {
'state': state,
'motion': motion,
'consequence': consequence,
'timestamp': timestamp,
'embedding': self._embed(state, motion, consequence)
}
self.episodes.append(episode)
if len(self.episodes) > self.capability:
self.episodes.pop(0)
def _embed(self, state, motion, consequence):
textual content = f"{state} {motion} {consequence}".decrease()
return hash(textual content) % 10000
def retrieve_similar(self, query_state, ok=3):
if not self.episodes:
return ()
query_emb = self._embed(query_state, "", "")
scores = ((abs(ep('embedding') - query_emb), ep) for ep in self.episodes)
scores.kind(key=lambda x: x(0))
return (ep for _, ep in scores(:ok))
def get_recent(self, n=5):
return self.episodes(-n:)
class SemanticMemory:
def __init__(self):
self.preferences = defaultdict(float)
self.patterns = defaultdict(checklist)
self.success_rates = defaultdict(lambda: {'success': 0, 'whole': 0})
def update_preference(self, key, worth, weight=1.0):
self.preferences(key) = 0.9 * self.preferences(key) + 0.1 * weight * worth
def record_pattern(self, context, motion, success):
pattern_key = f"{context}_{motion}"
self.patterns(context).append((motion, success))
self.success_rates(pattern_key)('whole') += 1
if success:
self.success_rates(pattern_key)('success') += 1
def get_best_action(self, context):
if context not in self.patterns:
return None
action_scores = defaultdict(lambda: {'success': 0, 'whole': 0})
for motion, success in self.patterns(context):
action_scores(motion)('whole') += 1
if success:
action_scores(motion)('success') += 1
best_action = max(action_scores.gadgets(), key=lambda x: x(1)('success') / max(x(1)('whole'), 1))
return best_action(0) if best_action(1)('whole') > 0 else None
def get_preference(self, key):
return self.preferences.get(key, 0.0)Wir definieren die Kernspeicherstrukturen, auf die sich unser Agent verlässt. Wir bauen ein episodisches Gedächtnis auf, um spezifische Erfahrungen zu erfassen, und ein semantisches Gedächtnis, um Muster im Laufe der Zeit zu verallgemeinern. Indem wir diese Grundlagen schaffen, bereiten wir den Agenten darauf vor, aus Interaktionen zu lernen, so wie es Menschen tun. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
class MemoryAgent:
def __init__(self):
self.episodic_memory = EpisodicMemory(capability=50)
self.semantic_memory = SemanticMemory()
self.current_plan = ()
self.session_count = 0
def understand(self, user_input):
user_input = user_input.decrease()
if any(phrase in user_input for phrase in ('suggest', 'recommend', 'what ought to')):
intent="advice"
elif any(phrase in user_input for phrase in ('bear in mind', 'favor', 'like', 'favourite')):
intent="preference_update"
elif any(phrase in user_input for phrase in ('do', 'full', 'end', 'activity')):
intent="task_execution"
else:
intent="dialog"
return {'intent': intent, 'uncooked': user_input}
def plan(self, state):
intent = state('intent')
user_input = state('uncooked')
similar_episodes = self.episodic_memory.retrieve_similar(user_input, ok=3)
plan = ()
if intent == 'advice':
genre_prefs = {ok: v for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok}
if genre_prefs:
best_genre = max(genre_prefs.gadgets(), key=lambda x: x(1))(0)
plan.append(('suggest', best_genre.exchange('genre_', '')))
else:
plan.append(('suggest', 'normal'))
elif intent == 'preference_update':
genres = ('sci-fi', 'fantasy', 'thriller', 'romance', 'thriller')
detected_genre = subsequent((g for g in genres if g in user_input), None)
if detected_genre:
plan.append(('update_preference', detected_genre))
elif intent == 'task_execution':
best_action = self.semantic_memory.get_best_action('activity')
if best_action:
plan.append(('execute', best_action))
else:
plan.append(('execute', 'default'))
self.current_plan = plan
return planWir konstruieren die Wahrnehmungs- und Planungssysteme des Agenten. Wir verarbeiten die Eingaben des Benutzers, erkennen Absichten und erstellen Pläne, indem wir die zuvor gebildeten Erinnerungen nutzen. Wir beginnen zu gestalten, wie der Agent seine nächsten Aktionen begründet und entscheidet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def act(self, motion):
action_type, param = motion
if action_type == 'suggest':
if param == 'normal':
return f"Let me be taught your preferences first! What genres do you get pleasure from?"
return f"Based mostly in your preferences, I like to recommend exploring {param}!"
elif action_type == 'update_preference':
self.semantic_memory.update_preference(f'genre_{param}', 1.0, weight=1.0)
return f"Received it! I am going to bear in mind you get pleasure from {param}."
elif action_type == 'execute':
return f"Executing activity with technique: {param}"
return "Motion accomplished"
def revise_plan(self, suggestions):
if 'no' in suggestions.decrease() or 'incorrect' in suggestions.decrease():
if self.current_plan:
action_type, param = self.current_plan(0)
if action_type == 'suggest':
genre_prefs = sorted(
((ok, v) for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok),
key=lambda x: x(1),
reverse=True
)
if len(genre_prefs) > 1:
new_genre = genre_prefs(1)(0).exchange('genre_', '')
self.current_plan = (('suggest', new_genre))
return True
return False
def replicate(self, state, motion, consequence, success):
self.episodic_memory.retailer(state('uncooked'), str(motion), consequence)
self.semantic_memory.record_pattern(state('intent'), str(motion), success)Wir definieren, wie der Agent Aktionen ausführt, seine Entscheidungen revidiert, wenn das Suggestions den Erwartungen widerspricht, und wie er durch die Speicherung von Erfahrungen reflektiert. Wir verbessern kontinuierlich das Verhalten des Agenten, indem wir ihn aus jeder Runde lernen lassen. Durch diese Schleife machen wir das System anpassungsfähig und selbstkorrigierend. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def run_session(self, user_inputs):
self.session_count += 1
print(f"n{'='*60}")
print(f"SESSION {self.session_count}")
print(f"{'='*60}n")
outcomes = ()
for i, user_input in enumerate(user_inputs, 1):
print(f"Flip {i}")
print(f"Person: {user_input}")
state = self.understand(user_input)
plan = self.plan(state)
if not plan:
print("Agent: I am unsure what to do with that.n")
proceed
response = self.act(plan(0))
print(f"Agent: {response}n")
success="suggest" in plan(0)(0) or 'replace' in plan(0)(0)
self.replicate(state, plan(0), response, success)
outcomes.append({
'flip': i,
'enter': user_input,
'intent': state('intent'),
'motion': plan(0),
'response': response
})
return outcomesWir simulieren reale Interaktionen, bei denen der Agent mehrere Benutzereingaben innerhalb einer einzigen Sitzung verarbeitet. Wir beobachten, wie sich der Zyklus Wahrnehmen → Planen → Handeln → Reflektieren immer wieder entfaltet. Während wir Sitzungen durchführen, sehen wir, wie der Agent nach und nach personalisierter und intelligenter wird. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def evaluate_memory_usage(agent):
print("n" + "="*60)
print("MEMORY ANALYSIS")
print("="*60 + "n")
print(f"Episodic Reminiscence:")
print(f" Complete episodes saved: {len(agent.episodic_memory.episodes)}")
if agent.episodic_memory.episodes:
print(f" Oldest episode: {agent.episodic_memory.episodes(0)('timestamp')}")
print(f" Newest episode: {agent.episodic_memory.episodes(-1)('timestamp')}")
print(f"nSemantic Reminiscence:")
print(f" Discovered preferences: {len(agent.semantic_memory.preferences)}")
for pref, worth in sorted(agent.semantic_memory.preferences.gadgets(), key=lambda x: x(1), reverse=True)(:5):
print(f" {pref}: {worth:.3f}")
print(f"n Motion patterns discovered: {len(agent.semantic_memory.patterns)}")
print(f"n Success charges by context-action:")
for key, stats in checklist(agent.semantic_memory.success_rates.gadgets())(:5):
if stats('whole') > 0:
charge = stats('success') / stats('whole')
print(f" {key}: {charge:.2%} ({stats('success')}/{stats('whole')})")
def compare_sessions(results_history):
print("n" + "="*60)
print("CROSS-SESSION ANALYSIS")
print("="*60 + "n")
for i, ends in enumerate(results_history, 1):
recommendation_quality = sum(1 for r in outcomes if 'preferences' in r('response').decrease())
print(f"Session {i}:")
print(f" Turns: {len(outcomes)}")
print(f" Customized responses: {recommendation_quality}")Wir analysieren, wie effektiv der Agent seine Erinnerungen nutzt. Wir überprüfen gespeicherte Episoden, erlernte Präferenzen und Erfolgsmuster, um zu bewerten, wie sich der Agent entwickelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.
def run_demo():
agent = MemoryAgent()
print("n📚 SCENARIO: Agent learns consumer preferences over a number of periods")
session1_inputs = (
"Hello, I am searching for one thing to learn",
"I actually like sci-fi books",
"Are you able to suggest one thing?",
)
results1 = agent.run_session(session1_inputs)
session2_inputs = (
"I am bored, what ought to I learn?",
"Really, I additionally get pleasure from fantasy novels",
"Give me a advice",
)
results2 = agent.run_session(session2_inputs)
session3_inputs = (
"What do you recommend for tonight?",
"I am within the temper for thriller too",
"Advocate one thing primarily based on what you recognize about me",
)
results3 = agent.run_session(session3_inputs)
evaluate_memory_usage(agent)
compare_sessions((results1, results2, results3))
print("n" + "="*60)
print("EPISODIC MEMORY RETRIEVAL TEST")
print("="*60 + "n")
question = "suggest sci-fi"
comparable = agent.episodic_memory.retrieve_similar(question, ok=3)
print(f"Question: '{question}'")
print(f"Retrieved {len(comparable)} comparable episodes:n")
for ep in comparable:
print(f" State: {ep('state')}")
print(f" Motion: {ep('motion')}")
print(f" Final result: {ep('consequence')(:50)}...")
print()
if __name__ == "__main__":
print("="*60)
print("MEMORY & LONG-TERM AUTONOMY IN AGENTIC SYSTEMS")
print("="*60)
run_demo()
print("n✅ Tutorial full! Key takeaways:")
print(" • Episodic reminiscence shops particular experiences")
print(" • Semantic reminiscence generalizes patterns")
print(" • Brokers enhance suggestions over periods")
print(" • Reminiscence retrieval guides future choices")Wir bringen alles zusammen, indem wir mehrere Sitzungen durchführen und den Speicherabruf testen. Wir beobachten, wie sich der Agent über Interaktionen hinweg verbessert und verfeinern Empfehlungen auf der Grundlage des gesammelten Wissens. Diese umfassende Demo veranschaulicht, wie sich aus den von uns entwickelten Speichersystemen auf natürliche Weise langfristige Autonomie ergibt.
Zusammenfassend erkennen wir, wie die Kombination aus episodischem und semantischem Gedächtnis es uns ermöglicht, Agenten zu entwickeln, die kontinuierlich lernen und im Laufe der Zeit immer bessere Entscheidungen treffen. Wir beobachten, wie der Agent Empfehlungen verfeinert, Pläne anpasst und vergangene Erfahrungen abruft, um seine Reaktionen Sitzung für Sitzung zu verbessern. Durch diese Mechanismen sehen wir, wie aus einfachen, aber effektiven Gedächtnisstrukturen langfristige Autonomie entsteht.
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.