Commit: 35fbd054cec56752630a2152d93e3ac3e10e3830 - zirpu (git)

Emergent generative agents

Commit MetaInfo

• Revisão: 35fbd054cec56752630a2152d93e3ac3e10e3830 (tree)
• Hora: 2023-04-15 01:38:46
• Autor: Corbin <cds@corb...>
• Commiter: Corbin

Mensagem de Log

Give sentence indices an inigo behavior.

The exponentially-decaying behavior appears to work well with the
given parsimony metric. I spitballed the exponent, based on a couple
thought files from some bots.

Temperature really should be lower, so I tweaked that too.

Mudança Sumário

• modified: agent.py
• modified: append_thought.py
• modified: common.py
• modified: gens/trans.py

Diff

--- a/agent.py
+++ b/agent.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env nix-shell
 #! nix-shell -i python3 -p python3Packages.irc python3Packages.faiss python3Packages.transformers python3Packages.torch
 
+from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from heapq import nsmallest
@@ -10,13 +11,10 @@ import random
 import re
 import sys
 
-from faiss import IndexFlatL2
-import numpy as np
-
 from irc.bot import SingleServerIRCBot
 from irc.strings import lower
 
-from common import Log, Timer, breakAt
+from common import Log, SentenceIndex, breakAt
 from gens.trans import Flavor, HFGen
 from gens.camelid import CamelidGen
 
@@ -46,29 +44,6 @@ def load_character(path):
     with open(os.path.join(path, "character.json"), "r") as handle:
         return json.load(handle)
 
-class SentenceIndex:
-    def __init__(self, path, dimensions):
-        self.path = path
-        self.index = IndexFlatL2(dimensions)
-
-    def load(self):
-        with open(self.path, "r") as handle:
-            data = json.load(handle)
-        self.db = list(data.items())
-        self.index.add(np.array([row[1] for row in self.db], dtype="float32"))
-
-    def save(self):
-        with open(self.path, "w") as f: json.dump(dict(self.db), f)
-
-    def search(self, embedding, k):
-        with Timer("%d nearest neighbors" % k):
-            D, I = self.index.search(np.array([embedding], dtype="float32"), k)
-            return [self.db[i][0] for i in I[0] if i >= 0]
-
-    def add(self, s, embedding):
-        self.index.add(np.array([embedding], dtype="float32"))
-        self.db.append((s, embedding))
-
 logpath = sys.argv[2]
 character = load_character(logpath)
 startingChannels = character.pop("startingChannels")
@@ -88,7 +63,7 @@ max_context_length = gen.contextLength()
 thought_index = SentenceIndex(os.path.join(logpath, "thoughts.json"),
                               llama_gen.embedding_width)
 thought_index.load()
-print("~ Thought index:", thought_index.index.ntotal, "thoughts")
+print("~ Thought index:", thought_index.size(), "thoughts")
 
 executor = ThreadPoolExecutor(max_workers=1)
 
@@ -108,6 +83,7 @@ class Agent(SingleServerIRCBot):
         self.startingChannels = startingChannels
         self.logpath = logpath
         self.logs = {}
+        self.willReply = defaultdict(bool)
 
     def on_join(self, c, e):
         channel = e.target
@@ -132,21 +108,19 @@ class Agent(SingleServerIRCBot):
         # https://github.com/jaraco/irc/blob/main/scripts/testbot.py
         nick = lower(self.connection.get_nickname())
         lowered = lower(line)
-        if self.thinking: print("~ Already thinking")
-        else:
-            self.thinkAbout(channel)
-            if (nick in lowered and random.random() <= 0.875):
-                self.generateReply(c, channel)
-            elif random.random() <= 0.125: self.generateReply(c, channel)
+        if nick in lowered or random.random() <= 0.125:
+            self.willReply[channel] = True
+        if not self.thinking: self.thinkAbout(c, channel)
 
     def thoughtPrompt(self):
         key = NO_THOUGHTS_EMBED if self.recent_thought is None else self.recent_thought[1]
-        # Fetch more thoughts than necessary, and always prefer shorter
+        # Fetch more thoughts than necessary, and then always prefer shorter
         # thoughts. This is an attempt to prevent exponential rumination.
-        new_thoughts = thought_index.search(key, 10)
-        # .search() returns most relevant thoughts first; reversing the list
-        # creates more focused chains of thought.
-        new_thoughts = nsmallest(5, new_thoughts.reverse(), key=len)
+        new_thoughts = thought_index.search(key, 20)
+        # XXX .search() returns most relevant thoughts first; reversing the list
+        # would create more focused chains of thought.
+        # Smaller thoughts are better.
+        new_thoughts = nsmallest(10, new_thoughts, key=len)
         if self.recent_thought is not None:
             new_thoughts.append(self.recent_thought[0])
         print("~ Thoughts:", *new_thoughts)
@@ -180,8 +154,10 @@ Users: {users}"""
         return "\n".join(lines)
 
     def generateReply(self, c, channel):
+        print("~ Will reply to channel:", channel)
+        self.willReply.pop(channel, None)
         log = self.logs[channel]
-        nick = self.connection.get_nickname()
+        nick = c.get_nickname()
         prefix = f"{datetime.now():%H:%M:%S} <{nick}>"
         examples = self.examplesFromOtherChannels(channel)
         # NB: "full" prompt needs log lines from current channel...
@@ -190,18 +166,20 @@ Users: {users}"""
         log.bumpCutoff(max_context_length, gen.countTokens, fullPrompt, prefix)
         # ...and current channel's log lines are added here.
         s = log.finishPrompt(fullPrompt, prefix)
-        print("~ log length:", len(log.l) - log.cutoff,
-              "prompt length (tokens):", gen.countTokens(s))
+        # print("~ log length:", len(log.l) - log.cutoff,
+        #       "prompt length (tokens):", gen.countTokens(s))
         # NB: At this point, execution is kicked out to a thread.
         def cb(completion):
             self.thinking = False
             reply = breakIRCLine(completion.result())
             log.irc(datetime.now(), nick, reply)
             c.privmsg(channel, reply)
+            if self.willReply:
+                self.generateReply(c, next(iter(self.willReply)))
         self.thinking = True
         executor.submit(lambda: gen.complete(s)).add_done_callback(cb)
 
-    def thinkAbout(self, channel):
+    def thinkAbout(self, c, channel):
         print("~ Will ponder channel:", channel)
         s = prompt + self.newThoughtPrompt(channel)
         def cb(completion):
@@ -211,6 +189,8 @@ Users: {users}"""
             embedding = llama_gen.embed(thought)
             self.recent_thought = thought, embedding
             thought_index.add(thought, embedding)
+            thought_index.prune()
+            if self.willReply[channel]: self.generateReply(c, channel)
         self.thinking = True
         executor.submit(lambda: gen.complete(s)).add_done_callback(cb)
 

--- a/append_thought.py
+++ b/append_thought.py
@@ -1,21 +1,24 @@
 #!/usr/bin/env nix-shell
-#! nix-shell -i python3 -p python3
+#! nix-shell -i python3 -p python3Packages.faiss
 
-import json, sys
+import sys
 
+from common import SentenceIndex
 from gens.camelid import CamelidGen
 
 path = sys.argv[-1]
 gen = CamelidGen()
+index = SentenceIndex(path, gen.embedding_width)
 
-with open(path, "r") as handle: db = json.load(handle)
-print("Thought database:", len(db), "entries")
+index.load()
+print("Thought database:", index.size(), "entries")
 
 while True:
     try: thought = input("> ").strip()
     except EOFError: break
     if not thought: break
-    db[thought] = gen.embed(thought)
+    index.add(thought, gen.embed(thought))
+    index.prune()
 
-print("Saving thought database:", len(db), "entries")
-with open(path, "w") as handle: json.dump(db, handle)
+print("Saving thought database:", index.size(), "entries")
+index.save()

--- a/common.py
+++ b/common.py
@@ -1,6 +1,11 @@
 from bisect import bisect
+import json
+import random
 from time import perf_counter
 
+from faiss import IndexFlatL2
+import numpy as np
+
 class Timer:
     "Basic context manager for timing an operation."
     def __init__(self, label): self.l = label
@@ -59,3 +64,48 @@ def parseLine(line, speakers):
     for edge in speakers:
         if not line.startswith(edge): line = breakAt(line, edge)
     return line.strip()
+
+def parsimony(s): return 1 - 2 ** -(len(s) * (1 / 50))
+
+class SentenceIndex:
+    def __init__(self, path, dimensions):
+        self.path = path
+        self.dimensions = dimensions
+        self.index = None
+
+    def size(self): return self.index.ntotal
+
+    def rebuild(self):
+        with Timer("rebuilding sentence index"):
+            self.index = IndexFlatL2(self.dimensions)
+            self.index.add(np.array([row[1] for row in self.db], dtype="float32"))
+
+    def load(self):
+        with open(self.path, "r") as handle:
+            data = json.load(handle)
+        self.db = list(data.items())
+        self.rebuild()
+
+    def save(self):
+        with open(self.path, "w") as f: json.dump(dict(self.db), f)
+
+    def search(self, embedding, k):
+        with Timer("%d nearest neighbors" % k):
+            D, I = self.index.search(np.array([embedding], dtype="float32"), k)
+            return [self.db[i][0] for i in I[0] if i >= 0]
+
+    def add(self, s, embedding):
+        self.index.add(np.array([embedding], dtype="float32"))
+        self.db.append((s, embedding))
+
+    def prune(self):
+        # NB: This is the same maths as an inigo. Older thoughts are less
+        # likely to be removed.
+        i = int(random.expovariate(1 / 5))
+        if not (0 < i < len(self.db)): return
+        thought = self.db[-i][0]
+        print("~ Is is short enough?", thought)
+        if random.random() <= parsimony(thought):
+            print("~ Would prune thought:", thought)
+            # self.db.pop(-i)
+            # self.rebuild()

--- a/gens/trans.py
+++ b/gens/trans.py
@@ -57,6 +57,6 @@ class HFGen:
                                  do_sample=True,
                                  # Force responses.
                                  min_length=5,
-                                 # Slightly sharpen results.
-                                 temperature=0.875, repetition_penalty=1.0625,
+                                 # Sharpen results.
+                                 temperature=0.75, repetition_penalty=1.125,
                                  )[0]["generated_text"]