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 plan

Wir 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 outcomes

Wir 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.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

Da Länder auf der ganzen Welt ein Wiederaufleben von Kernergieprojekten erleben, bleiben die Fragen, wo und wie man nuklearer Abfälle entsorgt wird, so politisch belastet wie nie zuvor. Die Vereinigten Staaten haben beispielsweise ihr einziges langfristiges unterirdisches Atomabfall-Repository auf unbestimmte Zeit eingestellt. Wissenschaftler verwenden sowohl Modellierungs- als auch experimentelle Methoden, um die Auswirkungen der Entsorgung unterirdischer Atomabfälle zu untersuchen, und hoffen letztendlich, dass sie das öffentliche Vertrauen in den Entscheidungsprozess aufbauen.

Neue Forschungen von Wissenschaftlern am MIT, Lawrence Berkeley Nationwide Lab und der College of Orléans machen Fortschritte in dieser Richtung. Die Studie zeigt, dass Simulationen von Wechselwirkungen zwischen unterirdischen Nuklearabfällen, die durch neue Hochleistungs-Komputier-Software program erzeugt wurden, intestine mit experimentellen Ergebnissen einer Forschungseinrichtung in der Schweiz ausgerichtet sind.

Die Studie, die von MIT PhD-Studentin Dauren Sarsenbayev und Assistenzprofessor Haruko Wainwright zusammen mit Christophe Tournassat und Carl Steeefel mitautorisiert wurde. erscheint in der Zeitschrift PNAs.

„Diese leistungsstarken neuen Computerwerkzeuge, verbunden mit realen Experimenten wie denjenigen auf dem Mont Terri-Forschungsort in der Schweiz, helfen uns zu verstehen, wie Radionuklide in gekoppelten Untergrundsystemen wandern werden“, sagt Sarsenbayev, der erster Autor der neuen Studie ist.

Die Autoren hoffen, dass die Forschung das Vertrauen der politischen Entscheidungsträger und der Öffentlichkeit in der langfristigen Sicherheit der Entsorgung unterirdischer Atomabfälle verbessern wird.

„Diese Forschung – die Kopplung sowohl Berechnung als auch Experimente – ist wichtig, um unser Vertrauen in Sicherheitsbewertungen von Abfällen zu verbessern“, sagt Wainwright. „Da sich die Kernenergie als wichtige Quelle für die Bekämpfung des Klimawandels und zur Gewährleistung der Energiesicherheit wieder auferlegt, ist es entscheidend, Entsorgungswege zu validieren.“

Vergleich von Simulationen mit Experimenten

Die Entsorgung von Atomabfällen in tief unterirdischen geologischen Formationen wird derzeit als die sicherste langfristige Lösung für die Behandlung von radioaktiven Abfällen auf hoher Ebene angesehen. Daher wurden viel Anstrengung in die Untersuchung des Migrationsverhaltens von Radionukliden aus Atomabfällen in verschiedenen natürlichen und konstruierten geologischen Materialien unternommen.

Seit seiner Gründung im Jahr 1996 conflict das Mont Terri-Forschungsgelände in der nördlichen Schweiz ein wichtiges Testbett für ein internationales Konsortium von Forschern, die sich für die Untersuchung von Materialien wie Opalinus-Ton interessieren-einen dicken, wasserdichten Tonstein in den Tunnelbereichen des Berges.

„Es gilt allgemein als eine der wertvollsten experimentellen Standorte in der Praxis, da es uns jahrzehntelange Datensätze rund um die Wechselwirkungen von Zement und Ton liefert, und dies sind die wichtigsten Materialien, die von Ländern auf der ganzen Welt für technische Barrieresysteme und geologische Repositories für Atomabfälle verwendet werden“, erklärt Sarsenbayev.

Für ihre Studie arbeiteten Sarsenbayev und Wainwright mit Co-Autoren Tournassat und Steeefel zusammen, die eine leistungsstarke Computersoftware entwickelt haben, um die Modellierung von Wechselwirkungen zwischen nuklearem Abfall und sowohl konstruierten als auch natürlichen Materialien zu verbessern.

Bisher haben mehrere Herausforderungen das Verständnis der Wissenschaftler, wie nuklearer Abfall mit Zement-Tonbarrieren reagiert. Zum einen bestehen die Barrieren aus unregelmäßig gemischten Materialien tief unter der Erde. Darüber hinaus berücksichtigen die vorhandene Klasse von Modellen, die üblicherweise zur Simulation von Radionuklid-Wechselwirkungen mit Zementschicht verwendet werden, elektrostatische Effekte nicht, die mit den negativ geladenen Tonmineralien in den Barrieren verbunden sind.

Die neue Software program von Tournassat und Steeefel berücksichtigt elektrostatische Effekte und macht sie die einzige, die diese Interaktionen im dreidimensionalen Raum simulieren kann. Die Software program namens Crunchoditi wurde aus der etablierten Software program entwickelt, die als Crunchflow bekannt ist und zuletzt in diesem Jahr aktualisiert wurde. Es ist so konzipiert, dass es auf vielen Hochleistungs-Computern gleichzeitig gleichzeitig betrieben werden kann.

Für die Studie untersuchten die Forscher ein 13-jähriges Experiment mit einem ersten Fokus auf Zement-Clay-Gesteins-Wechselwirkungen. In den letzten Jahren wurde dem Bohrloch in der Nähe des Zementes der in der Formation befindlichen Bohrloch eine Mischung sowohl negativ als auch positiv geladene Ionen hinzugefügt. Die Forscher konzentrierten sich auf eine 1-Zentimeter-dicke Zone zwischen den Radionukliden und dem Zement-Ton, der als „Haut“ bezeichnet wird. Sie verglichen ihre experimentellen Ergebnisse mit der Softwaresimulation und fanden die beiden Datensätze aus.

„Die Ergebnisse sind sehr wichtig, da diese Modelle zuvor nicht sehr intestine Felddaten passen würden“, sagt Sarsenbayev. „Es ist interessant, wie feines Maßstabphänomen am“ Haut „zwischen Zement und Ton, die physikalischen und chemischen Eigenschaften, deren sich im Laufe der Zeit ändert, verwendet werden, um die experimentellen und Simulationsdaten in Einklang zu bringen.“

Die experimentellen Ergebnisse zeigten, dass das Modell erfolgreich elektrostatische Effekte im Zusammenhang mit der Tonbildung und der Wechselwirkung zwischen Materialien in Mont Terri im Laufe der Zeit berücksichtigte.

„Dies alles wird von Jahrzehnten der Arbeit angetrieben, um zu verstehen, was an diesen Schnittstellen passiert“, sagt Sarsenbayev. „Es wurde angenommen, dass an dieser Grenzfläche mineralische Niederschläge und Porosität vorhanden sind, und unsere Ergebnisse deuten nachdrücklich darauf hin.“

„Diese Anwendung erfordert Millionen von Freiheitsgraden, da diese Multiberziersysteme eine hohe Auflösung und viel Rechenleistung erfordern“, sagt Sarsenbayev. „Diese Software program ist wirklich ideally suited für das Mont Terri -Experiment.“

Bewertung von Abfallentsorgungsplänen

Das neue Modell könnte nun ältere Modelle ersetzen, die zur Durchführung von Sicherheits- und Leistungsbewertungen von unterirdischen geologischen Repositorys verwendet wurden.

„Wenn die USA schließlich beschließen, Atomabfälle in einem geologischen Repository zu entsorgen, könnten diese Modelle die am besten geeigneten Materialien bestimmen“, sagt Sarsenbayev. „Zum Beispiel wird Ton jetzt als geeignetes Lagermaterial angesehen, aber Salzformationen sind ein weiteres potenzielles Medium, das verwendet werden könnte. Diese Modelle ermöglichen es uns, das Schicksal von Radionukliden über Jahrtausende zu erkennen. Wir können sie verwenden, um Interaktionen zu Zeitspannern zu verstehen, die von Monaten bis zu Jahren bis zu vielen Millionen Jahren variieren.“

Laut Sarsenbayev ist das Modell für andere Forscher vernünftigerweise zugänglich und zukünftige Bemühungen könnten sich auf die Verwendung von maschinellem Lernen konzentrieren, um weniger rechnerisch teure Ersatzmodelle zu entwickeln.

Weitere Daten aus dem Experiment werden später in diesem Monat verfügbar sein. Das Staff plant, diese Daten mit zusätzlichen Simulationen zu vergleichen.

„Unsere Mitarbeiter erhalten im Grunde genommen diesen Zement- und Tonblock und können Experimente durchführen, um die genaue Hautdicke zusammen mit allen an dieser Grenzfläche vorhandenen Mineralien und Prozessen zu bestimmen.“ Sarsenbayev sagt. „Es ist ein riesiges Projekt und es braucht Zeit, aber wir wollten die ersten Daten und diese Software program so schnell wie möglich teilen.“

Derzeit hoffen die Forscher, dass ihre Studie zu einer langfristigen Lösung zur Speicherung von Atomabfällen führt, die die politischen Entscheidungsträger und die Öffentlichkeit unterstützen können.

„Dies ist eine interdisziplinäre Studie, die Experimente der realen Welt umfasst, die zeigen, dass wir das Schicksal von Radionukliden im Untergrund vorhersagen können“, sagt Sarsenbayev. „Das Motto des Abteilung für Nuklearwissenschaften und -technik des MIT ist ‚Science. Systeme. Society.‘ Ich denke, das verschmilzt alle drei Domänen. “