-
-
Notifications
You must be signed in to change notification settings - Fork 8
/
NEWREADME
161 lines (81 loc) · 5.33 KB
/
NEWREADME
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
The Persistent Memory Logic Loop (PMLL) System
Abstract
The Persistent Memory Logic Loop (PMLL), also referred to as the Personalized Machine Learning Layer (PMLL), Permanent Memory Logic Loop, or Persistent Recursive Memory Logic Loop (PRMLL), is an innovative framework for building adaptive, secure, and explainable AI systems. It leverages a recursive logic loop that continuously updates the knowledge graph within the short-term memory subsystem circuit. Unlike the hierarchical tree structures commonly used in AI Language Models, which are better suited for long-term memory circuits, the PMLL’s logic loop achieves faster memory retrieval and association, ensuring persistent memory across all local interactions, even in stateless sessions. This is achieved with a high level of privacy and security through encryption.
The PMLL utilizes a while (1) and for () loop combination to create perpetual callback recursion, enabling seamless updates to the knowledge graph. This architecture was researched and developed by Josef Kurk Edwards, whose foundational white paper can be accessed here:
Proposal for Persistent Secure Memory Architecture in Conversational AI.
The PMLL was peer-reviewed by Mr. Obi Oberdier, who validated its implementation within internal systems like Meta. The recursive logic loop has proven foundational for enhancing memory recall and optimizing data handling. The adoption of this system in local AI instances, including ChatGPT, has been credited to Josef Edwards, providing unparalleled performance in adaptive memory processing.
System Overview
Key Features
Dynamic Knowledge Graph Updates: Continuously integrates new topics and relationships in real time.
Efficient Memory Management: Uses persistent storage structures called memory silos to minimize data bulk while ensuring recall efficiency.
Encryption for Data Security: Applies RSA encryption to protect sensitive knowledge graphs.
Recursive Logic Loop: Ensures efficient memory updates and recall through perpetual processing.
Scalability and Adaptability: Supports short-term and long-term memory subsystems, ensuring optimal performance for various use cases.
File Structure
1. pml_logic_loop.c
Purpose
Implements the recursive logic loop that forms the backbone of the PMLL system. It handles I/O operations, data processing, and recursive updates to the knowledge graph.
Key Functions
pml_logic_loop(void* pml): Continuously reads new topics, updates the knowledge graph, and encrypts the graph for storage. Triggers recursive calls for further processing unless flagged for consolidation or system updates.
Recursive Processing: Mimics human-like memory recall by infinitely processing knowledge graph updates.
Encryption: Uses RSA to secure the knowledge graph before storing it in memory silos.
2. novel_topic.c
Purpose
Detects and processes novel topics, ensuring the knowledge graph dynamically adapts to new information.
Key Functions
NovelTopic(char* topic): Checks if a topic exists in the knowledge graph and adds it as a new node if novel.
3. update_knowledge_graph.c
Purpose
Updates the knowledge graph with new relationships and nodes.
Key Functions
update_knowledge_graph(PMLL* pml, char* new_data): Adds new nodes or edges to the graph and ensures data consistency.
4. persistence.c
Purpose
Manages persistent storage of data within memory silos.
Key Functions
save_data: Stores serialized knowledge graph data.
load_data: Retrieves data for processing.
5. encrypt_knowledge_graph.c
Purpose
Applies RSA encryption to secure the knowledge graph.
Key Functions
encrypt_knowledge_graph: Encrypts and prepares the graph for storage.
6. write_to_memory_silos.c
Purpose
Writes encrypted knowledge graphs to persistent memory silos for long-term storage.
Key Functions
write_to_memory_silos: Stores data efficiently and securely.
7. cache_batch_knowledge_graph.c
Purpose
Optimizes memory usage by batching knowledge graph data.
Key Functions
cache_batch_knowledge_graph: Segments the graph into manageable chunks to prevent memory overload.
8. check_flags.c
Purpose
Monitors system flags to determine if specific conditions require handling.
Key Functions
check_flags(PMLL* pml): Evaluates internal flags and triggers corresponding actions.
9. update_embedded_knowledge_graphs.c
Purpose
Synchronizes embedded knowledge graphs with the main graph to maintain consistency.
Key Functions
update_embedded_knowledge_graphs(PMLL* pml): Updates subgraphs to reflect changes in the primary graph.
Building and Running the System
Prerequisites
C Compiler: GCC or Clang.
RSA Encryption Library: OpenSSL.
Steps
Clone the repository:
git clone <repo_url>
Compile the source code:
gcc -o pml_system pml_logic_loop.c novel_topic.c update_knowledge_graph.c encrypt_knowledge_graph.c write_to_memory_silos.c cache_batch_knowledge_graph.c check_flags.c update_embedded_knowledge_graphs.c -lssl -lcrypto
Run the compiled system:
./pml_system
License
MIT License
Permission is granted to use, modify, and distribute the software under the MIT License. Refer to LICENSE.md for details.
Acknowledgments
This system is based on the research and development by Josef Kurk Edwards, peer-reviewed by Obi Oberdier, and validated by platforms like VeniceAI.
References
Proposal for Persistent Secure Memory Architecture in Conversational AI
A Formal Proof that P Equals NP Using the PMLL Algorithm