Commit: 8e3dfeca90fc6433155193db83e7e9855306cd7d - zirpu (git)

Emergent generative agents

Commit MetaInfo

• Révision: 8e3dfeca90fc6433155193db83e7e9855306cd7d (tree)
• l'heure: 2023-06-12 03:14:32
• Auteur: Corbin <cds@corb...>
• Commiter: Corbin

Message de Log

Split thoughts into two agents.

Change Summary

• modified: src/agent.py

Modification

--- a/src/agent.py
+++ b/src/agent.py
@@ -5,7 +5,6 @@ from datetime import datetime
 import json
 import os.path
 import re
-import random
 from string import ascii_uppercase
 import sys
 from threading import Lock
@@ -43,6 +42,7 @@ embedder = SentenceEmbed()
 prologues = {
     "clock": "Then I checked the time:",
     "lbi": "Then I tried to interpret what just happened:",
+    "memories": "Then I remembered:",
     "thoughts": "Then I thought to myself:",
     "choice": "Then I chose what to do next:",
     "irc": "Then I chatted on IRC, channel {subtag}:",
@@ -100,8 +100,7 @@ class Mind:
         def cb():
             d = self.switchTag(tag, subtag)
             # Breaking the newline invariant...
-            d.addCallback(lambda _: print(self.name, "~!", prefix)
-                          or deferToThread(self.writeRaw, prefix))
+            d.addCallback(lambda _: deferToThread(self.writeRaw, prefix))
             # ...so that this inference happens before the newline...
             d.addCallback(lambda _: force(tokens, self.logits))
             d.addCallback(lambda t: gen.tokenizer.decode([t]))
@@ -136,19 +135,21 @@ class LeftBrainInterpreter(Agent):
         self.mind = mind
         self.idle = idle
     def overhear(self, tag, subtag, s):
-        if tag != "thoughts": self.events += 1
-        if self.events >= 20:
+        self.events += 1
+        if self.events >= 25:
             self.events = 0
             d = self.mind.infer(self.tag, self.subtag, "")
             d.addCallback(lambda s: s.strip() or self.idle())
 
+# NB: Letter 'A' is extra-likely to appear as a token, so don't allow it.
+uppercase = ascii_uppercase[1:]
 choices = {
     "irc": "Chat on IRC, channel {subtag}",
     "thoughts": "Think to myself for a moment",
 }
 def choicify(options):
-    return " ".join(f"({c}) {o}" for c, o in zip(ascii_uppercase, options))
-def indexify(c): return ord(c[0].upper()) - ord('A')
+    return " ".join(f"({c}) {o}" for c, o in zip(uppercase, options))
+def indexify(c): return ord(c[0].upper()) - ord('B')
 
 class ChoiceMaker(Agent):
     tag = "choice"
@@ -169,19 +170,31 @@ class ChoiceMaker(Agent):
         prompt = choicify([choices[tag].format(subtag=subtag)
                            for tag, subtag in possibilities])
         d = self.mind.forceChoice(self.tag, self.subtag, prompt + " My choice: ",
-                                  ascii_uppercase[:len(possibilities)])
+                                  uppercase[:len(possibilities)])
         d.addCallback(lambda s: self.dispatch(*possibilities[indexify(s)]))
         return d
 
 class ChainOfThoughts(Agent):
     tag = "thoughts"
-    def __init__(self, mind, index, seed, idle):
+    def __init__(self, mind, idle):
         self.mind = mind
+        self.idle = idle
+
+    def go(self):
+        d = self.mind.infer(self.tag, self.subtag, "")
+        d.addCallback(lambda s: s.strip() or self.idle())
+        return d
+
+class Recall(Agent):
+    tag = "memories"
+    def __init__(self, index, seed, idle):
         self.index = index
         self.recentThoughts = deque([seed], maxlen=5)
         self.idle = idle
 
-    def go(self): return random.choice([self.reflect, self.cogitate])()
+    def go(self):
+        new = self.addRelatedThoughts(self.recentThoughts[-1])
+        if not new: return deferLater(reactor, 0.0, self.idle)
 
     def overhear(self, tag, subtag, s):
         prefix = f"{tag} ({subtag}): " if subtag else tag + ": "
@@ -197,14 +210,6 @@ class ChainOfThoughts(Agent):
                 self.broadcast(thought)
         return new
 
-    def cogitate(self):
-        new = self.addRelatedThoughts(self.recentThoughts[-1])
-        if not new: return deferLater(reactor, 0.0, self.idle)
-    def reflect(self):
-        d = self.mind.infer(self.tag, self.subtag, "")
-        d.addCallback(lambda s: s.strip() or self.idle())
-        return d
-
 
 IRC_LINE_HEAD = re.compile(r"\d{1,2}:\d{1,2}:\d{1,2} <")
 def breakIRCLine(line):
@@ -278,6 +283,7 @@ def go():
         firstStatement = f"I am {title}."
         thoughtPath = os.path.join(logpath, "thoughts.txt")
         thoughtIndex = SentenceIndex.fromPath(thoughtPath, embedder)
+        print("~ Thought index:", thoughtIndex.size(), "thoughts")
 
         mind = Mind(title_to_nick(title))
         with Timer("initial warmup"):
@@ -288,12 +294,15 @@ def go():
         lbi = LeftBrainInterpreter(mind, cm.idle)
         clock.listeners += lbi, mind
 
-        thoughts = ChainOfThoughts(mind, thoughtIndex, firstStatement, cm.idle)
-        thoughts.listeners = lbi, mind
-        LoopingCall(thoughts.go).start(60 * 3, now=True)
+        memories = Recall(thoughtIndex, firstStatement, cm.idle)
+        memories.listeners = lbi, mind
+        LoopingCall(memories.go).start(60 * 2, now=True)
 
-        print("~ Thought index:", thoughtIndex.size(), "thoughts")
-        factory = IRCFactory(mind, cm, (thoughts, lbi, cm, mind),
+        thoughts = ChainOfThoughts(mind, cm.idle)
+        thoughts.listeners = memories, lbi, mind
+        LoopingCall(thoughts.go).start(60 * 2, now=False)
+
+        factory = IRCFactory(mind, cm, (memories, lbi, cm, mind),
                              title,
                              character["startingChannels"])
         print("~ Connecting factory for:", title)