goodai ltm
1.0.0
GoodAI-LTM stattet Agenten mit einem textbasierten Langzeitgedächtnis aus, indem es wesentliche Komponenten wie Texteinbettungsmodelle, Reranking, Vektordatenbanken, Speicher- und Abfrageumschreibung, automatisches Chunking, Chunk-Metadaten und Chunk-Erweiterung kombiniert. Dieses Paket wurde speziell entwickelt, um einen dialogzentrierten Speicherstream für soziale Agenten bereitzustellen.
Darüber hinaus enthält GoodAI-LTM eine Conversational Agent-Komponente (LTMAgent) für die nahtlose Integration in Python-basierte Apps.
pip install goodai-ltm
Rufen Sie die reply einer LTMAgent -Instanz auf, um eine Antwort vom Agenten zu erhalten.
from goodai.ltm.agent import LTMAgent
agent = LTMAgent(model="gpt-3.5-turbo")
response = agent.reply("What can you tell me about yourself?")
print(response)
Der model kann der Name eines beliebigen Modells sein, das von der Litellm-Bibliothek unterstützt wird.
Der Agent verwaltet automatisch einen Sitzungsverlauf. Wenn Sie eine neue Sitzung starten möchten, rufen Sie die Methode new_session auf.
agent.new_session()
print(f"Number of messages in session: {len(agent.session.message_history)}")
Der Agent verfügt über ein Gesprächsgedächtnis und eine Wissensdatenbank. Sie können den Agenten anweisen, Wissen zu speichern, indem Sie die Methode add_knowledge aufrufen.
agent.clear_knowledge()
agent.add_knowledge("The user's birthday is February 10.")
agent.add_knowledge("Refer to the user as 'boss'.")
response = agent.reply("Today is February 10. I think this is an important date. Can you remind me?")
print(response)
LTMAgent ist ein nahtloses RAG-System. Das Beispiel „ltm_agent_with_wiki“ zeigt, wie Wikipedia-Artikel zur Wissensdatenbank des Agenten hinzugefügt werden.
Sie können die Konfiguration des Agenten und seine Erinnerungen/Wissen beibehalten, indem Sie seinen Status als String über die Methode state_as_text abrufen.
state_text = agent.state_as_text()
# Persist state_text to secondary storage
Um einen Agenten aus Zustandstext zu erstellen, rufen Sie die Methode from_state_text auf.
agent2 = LTMAgent.from_state_text(state_text)
Beachten Sie, dass dadurch die Konversationssitzung nicht wiederhergestellt wird. Um die Konversationssitzung beizubehalten, rufen Sie die Methode state_as_text der Sitzung auf.
from goodai.ltm.agent import LTMAgentSession
session_state_text = agent.session.state_as_text()
# session_state_text can be persisted in secondary storage
# The session.session_id field can serve as an identifier of the persisted session
# Now let's restore the session in agent2
p_session = LTMAgentSession.from_state_text(session_state_text)
agent2.use_session(p_session)
Der folgende Codeausschnitt erstellt eine Instanz des LTM, lädt Text ein und ruft dann bei einer Abfrage die relevantesten Textpassagen (erweiterte Abschnitte) ab:
from goodai.ltm.mem.auto import AutoTextMemory
mem = AutoTextMemory.create()
mem.add_text("Lorem ipsum dolor sit amet, consectetur adipiscing elitn")
mem.add_text("Duis aute irure dolor in reprehenderit in voluptate velit esse cillum doloren",
metadata={'title': 'My document', 'tags': ['latin']})
r_memories = mem.retrieve(query='dolorem eum fugiat quo voluptas nulla pariatur?', k=3)
Eine Standardspeicherinstanz kann wie folgt erstellt werden:
from goodai.ltm.mem.auto import AutoTextMemory
mem = AutoTextMemory.create()
Sie können den Speicher auch konfigurieren, indem Sie Parameter an die Methode create übergeben. Im folgenden Beispiel verwendet der Speicher einen „gpt2“-Tokenizer zum Chunking, ein T5-Modell für Einbettungen, einen FAISS-Index zum Einbetten von Speicher anstelle einer einfachen Vektordatenbank und eine benutzerdefinierte Chunking-Konfiguration.
import torch
from transformers import AutoTokenizer
from goodai.ltm.embeddings.auto import AutoTextEmbeddingModel
from goodai.ltm.mem.auto import AutoTextMemory
from goodai.ltm.mem.config import TextMemoryConfig
from goodai.ltm.mem.mem_foundation import VectorDbType
embedding_model = AutoTextEmbeddingModel.from_pretrained('st:sentence-transformers/sentence-t5-base')
tokenizer = AutoTokenizer.from_pretrained('gpt2')
config = TextMemoryConfig()
config.chunk_capacity = 30 # tokens
config.queue_capacity = 10000 # chunks
mem = AutoTextMemory.create(emb_model=embedding_model,
matching_model=None,
tokenizer=tokenizer,
vector_db_type=VectorDbType.FAISS_FLAT_L2,
config=config,
device=torch.device('cuda:0'))
Rufen Sie die Methode add_text auf, um dem Speicher Text hinzuzufügen. Text kann aus Phrasen, Sätzen oder Dokumenten bestehen.
mem.add_text("Lorem ipsum dolor sit amet, consectetur adipiscing elitn")
Intern wird der Text vom Speicher automatisch aufgeteilt und indiziert.
Text kann einem beliebigen Metadatenwörterbuch zugeordnet werden, z. B.:
mem.add_text("Duis aute irure dolor in reprehenderit in voluptate velit esse cillum doloren",
metadata={'title': 'My document', 'tags': ['latin']})
Der Speicher verkettet mit add_text gespeicherten Text mit jedem zuvor an den Speicher gesendeten Text. Sie können jedoch add_separator aufrufen, um sicherzustellen, dass kein neuer Text zu zuvor erstellten Blöcken hinzugefügt wird.
Um eine Liste von Passagen abzurufen, die einer Abfrage zugeordnet sind, rufen Sie die retrieve auf:
r_memories = mem.retrieve("What does Jake propose?", k=2)
Die retrieve -Methode gibt eine Liste von Objekten vom Typ RetrievedMemory in absteigender Reihenfolge ihrer Relevanz zurück. Jeder abgerufene Speicher hat die folgenden Eigenschaften:
passage : Der Text der Erinnerung. Dies entspricht Text, der in einem passenden Block gefunden wurde, kann jedoch mit Text aus benachbarten Blöcken erweitert werden.timestamp : Die Zeit (standardmäßig Sekunden seit Epoche), zu der der abgerufene Block erstellt wurde.distance : Berechneter Abstand zwischen der Abfrage und der Blockpassage.relevance : Eine Zahl zwischen 0 und 1, die die Relevanz des abgerufenen Speichers darstellt.confidence : Wenn ein Abfragepassage-Matching-Modell verfügbar ist, ist dies die vom Modell zugewiesene Wahrscheinlichkeit.metadata : Metadaten, die mit dem abgerufenen Text verknüpft sind, falls vorhanden. Ein Einbettungsmodell wird wie folgt geladen:
from goodai.ltm.embeddings.auto import AutoTextEmbeddingModel
em = AutoTextEmbeddingModel.from_pretrained(model_name)
Der model_name kann einer der folgenden sein:
"st:" , zum Beispiel "st:sentence-transformers/multi-qa-mpnet-base-cos-v1" ."flag:" , zum Beispiel "flag:BAAI/bge-base-en-v1.5" ."openai:" , zum Beispiel "openai:text-embedding-ada-002" .| Name | Basismodell | # Parameter | # Speicher-Emb |
|---|---|---|---|
| em-MiniLM-p1-01 | multi-qa-MiniLM-L6-cos-v1 | 22,7 m | 1 |
| em-MiniLM-p3-01 | multi-qa-MiniLM-L6-cos-v1 | 22,7 m | 3 |
| em-distilroberta-p1-01 | Satztransformatoren/all-distrilroberta-v1 | 82,1 m | 1 |
| em-distilroberta-p3-01 | Satztransformatoren/all-distrilroberta-v1 | 82,1 m | 3 |
| em-distilroberta-p5-01 | Satztransformatoren/all-distrilroberta-v1 | 82,1 m | 5 |
Um Einbettungen für eine Liste von Abfragen zu erhalten, rufen Sie die Methode encode_queries wie folgt auf:
r_emb = em.encode_queries(['hello?'])
Dies gibt ein Numpy-Array zurück. Um einen Pytorch-Tensor zu erhalten, fügen Sie den Parameter convert_to_tensor hinzu:
r_emb = em.encode_queries(['hello?'], convert_to_tensor=True)
Um Einbettungen für eine Liste von Passagen zu erhalten, rufen Sie die Methode encode_corpus wie folgt auf:
s_emb = em.encode_corpus(['it was...', 'the best of...'])
Abfragen und Passagen können mehr als eine Einbettung haben. Einbettungstensoren haben drei Achsen: die Stapelgröße, die Anzahl der Einbettungen und die Anzahl der Einbettungsdimensionen. Normalerweise beträgt die Anzahl der Einbettungen pro Abfrage/Passage 1, mit einigen Ausnahmen.
Ein Abfragepassagen-Matching-/Reranking-Modell kann wie folgt geladen werden:
from goodai.ltm.reranking.auto import AutoTextMatchingModel
model = AutoTextMatchingModel.from_pretrained(model_name)
Der model_name kann einer der folgenden sein:
Speicherinstanzen verwenden standardmäßig kein Abfragepassage-Matching-Modell. Um eines zu aktivieren, sollte es wie folgt konfiguriert werden:
from goodai.ltm.embeddings.auto import AutoTextEmbeddingModel
from goodai.ltm.mem.auto import AutoTextMemory
from goodai.ltm.mem.config import TextMemoryConfig
from goodai.ltm.reranking.auto import AutoTextMatchingModel
# Low-resource embedding model
emb_model = AutoTextEmbeddingModel.from_pretrained('em-MiniLM-p1-01')
# QPM model that boosts retrieval accuracy
qpm_model = AutoTextMatchingModel.from_pretrained('em:em-distilroberta-p5-01')
config = TextMemoryConfig()
config.reranking_k_factor = 8
mem = AutoTextMemory.create(matching_model=qpm_model, emb_model=emb_model, config=config)
Die Einstellung reranking_k_factor teilt dem Speicher mit, wie viele Kandidaten er für die Neubewertung berücksichtigen soll. Der Benutzer fordert k Speicher an. Der Reranking-Algorithmus berücksichtigt k * reranking_k_factor Blöcke.
Die predict des Modells verwendet eine Liste von Abfrage-Passage-Tupeln und gibt eine Liste von Floats zurück, die geschätzte Übereinstimmungswahrscheinlichkeiten darstellen. Beispiel:
model = AutoTextMatchingModel.from_pretrained('em:em-distilroberta-p5-01')
sentences = [
('Mike: What is your favorite color?', 'Steve: My favorite color is purple.'),
('Name the inner planets.', 'It was the best of times, it was the worst of times.'),
]
prob = model.predict(sentences)
print(prob)
Siehe die README-Datei zu den Bewertungen.
Weitere Informationen finden Sie auf der Projektseite „goodai-ltm-benchmark“.
Weitere Beispielcodes finden Sie im examples .
