memorysafe 0.1.0__tar.gz

memorysafe-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+# Apache License
+Version 2.0, January 2004  
+http://www.apache.org/licenses/
+
+Copyright 2026 MemorySafe Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

memorysafe-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: memorysafe
+Version: 0.1.0
+Summary: MemorySafe: MVI-driven memory governance for continual learning systems.
+Author: Carla P. Centeno
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: mvi-metrics
+Requires-Dist: numpy
+Dynamic: license-file

memorysafe-0.1.0/README.md

@@ -0,0 +1,186 @@
+# MemorySafe Labs  
+**Memory Governance for Continual Learning Systems**
+
+## 🚀 Public Demo (Colab)
+
+Run the MemorySafe public demo comparing MemorySafe-Taste vs FIFO:
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MemorySafe-Labs/memorysafe/blob/main/benchmarks/Taste_Demo_MemorySafe_Taste_vs_FIFO_%20(1).ipynb)
+
+
+MemorySafe is a memory governance framework for continual learning systems, designed to prevent safety-critical information from being forgotten under memory and compute constraints.
+
+Rather than modifying how models learn, MemorySafe governs **what they retain**.
+
+It operates as a policy-level decision layer for memory, acting as an intelligent governor that disciplines data retention independently of the learning algorithm.
+
+Use cases include medical AI, edge systems, fraud detection, robotics, and privacy-aware AI.
+
+---
+
+## Problem
+
+Modern continual learning systems implicitly conflate **exposure with importance**.
+
+Under standard replay strategies:
+- frequent samples dominate memory,
+- rare but critical events are overwritten,
+- long-term reliability degrades.
+
+This is especially harmful in:
+- medical AI,
+- edge systems,
+- fraud detection,
+- safety-critical robotics.
+
+MemorySafe reframes memory as a **resource allocation and lifecycle management problem**, explicitly separating:
+
+> **Risk ≠ Value ≠ Decision**
+
+---
+
+## Core Concepts
+
+### 1. Memory Vulnerability Index (MVI)
+MVI estimates how likely a memory is to be forgotten under future learning pressure.
+
+It captures:
+- interference from new tasks,
+- sensitivity to gradient updates,
+- temporal competition effects.
+
+MVI is:
+- predictive (not retrospective),
+- continuous and interpretable,
+- model-agnostic.
+
+### 2. Memory Relevance (Value)
+Relevance estimates how valuable a memory is, independently of its vulnerability.
+
+Guiding principles:
+- repetition ≠ importance,
+- rare but salient events retain value,
+- relevance decays over time.
+
+### 3. ProtectScore (Decision Signal)
+ProtectScore combines MVI and Relevance into a deterministic decision signal that governs:
+- protection,
+- consolidation,
+- eviction under fixed capacity.
+
+This treats forgetting as an **active, functional choice**, not a system failure.
+
+---
+
+## What MemorySafe Is (and Is Not)
+
+**MemorySafe is:**
+- a memory governance layer,
+- compatible with any learning algorithm,
+- model-agnostic and pluggable,
+- interpretable and low-overhead.
+
+**MemorySafe is not:**
+- a replacement for training,
+- a full continual learning algorithm,
+- a benchmark-optimized model.
+
+It governs **memory decisions**, not learning dynamics.
+
+---
+
+## Architecture
+
+MemorySafe acts as a policy layer on top of replay buffers or memory modules.
+
+It maintains per-memory attributes:
+- task_id  
+- MVI  
+- relevance  
+- protect_score  
+- replay_count  
+- protected flag  
+
+Guarantees:
+- no gradients inside memory logic,
+- no dataset-specific heuristics,
+- deterministic and auditable behavior.
+
+---
+
+## Generalization & Validation
+
+The same unchanged MemorySafe policy was evaluated across heterogeneous continual learning benchmarks:
+
+- MNIST  
+- Fashion-MNIST  
+- CIFAR-10  
+- CIFAR-100  
+- Omniglot  
+- Permuted MNIST  
+- PneumoniaMNIST (medical imaging)
+
+Without dataset-specific tuning, MemorySafe demonstrated:
+- consistent Task-0 protection,
+- strong rare-event retention,
+- stability across increasing task difficulty.
+
+These results indicate **zero-shot generalization of a memory allocation policy**.
+
+---
+
+## Use Cases
+
+- **Medical AI**  
+  Protection of rare pathologies and safety-critical cases.
+
+- **Edge AI (Jetson / embedded)**  
+  Memory governance under tight RAM and compute budgets.
+
+- **Fraud Detection**  
+  Retention of delayed or rare anomalies.
+
+- **Robotics**  
+  Preservation of critical failures and safety events.
+
+- **Privacy-Aware AI**  
+  Predictive forgetting and sensitive data governance (MVI-P).
+
+---
+
+## Integration
+
+MemorySafe is compatible with:
+
+- Experience Replay  
+- GEM / A-GEM  
+- PackNet  
+- Progressive Neural Networks  
+- Custom replay buffers  
+
+It can be integrated as:
+- a replay gate,
+- an eviction governor,
+- a diagnostic layer for memory risk.
+
+---
+
+## Technology Stack
+
+- PyTorch  
+- CUDA / GPU accelerated training  
+- Designed for integration with modern ML pipelines  
+- Research prototype (Alpha)
+
+---
+
+## One-Sentence Essence
+
+**MemorySafe treats AI memory as a governed resource, separating vulnerability from value to enable intentional, interpretable, and generalizable memory decisions under real-world constraints.**
+
+## License
+
+MemorySafe is released under the Apache 2.0 License.
+
+This allows free use, modification, and distribution, including for commercial purposes.
+For enterprise support, integrations, or commercial partnerships, contact MemorySafe Labs.

memorysafe-0.1.0/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "memorysafe"
+version = "0.1.0"
+description = "MemorySafe: MVI-driven memory governance for continual learning systems."
+authors = [{name = "Carla P. Centeno"}]
+dependencies = ["mvi-metrics", "numpy"]
+requires-python = ">=3.10"
+license = {text = "MIT"}

memorysafe-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

memorysafe-0.1.0/src/memorysafe/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.0"
+
+from .buffer import TasteMemorySafeBuffer
+
+__all__ = ["__version__", "TasteMemorySafeBuffer"]

memorysafe-0.1.0/src/memorysafe/buffer.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Dict
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+@dataclass
+class MemoryItem:
+    x: torch.Tensor
+    y: int
+    protect_score: float
+    seen_step: int
+
+
+class TasteMemorySafeBuffer:
+    """
+    Public demo buffer (non-IP). Not the proprietary MemorySafe policy/MVI.
+    Keeps top protect_score items under fixed capacity and replays samples.
+    """
+
+    def __init__(self, capacity: int = 300):
+        self.capacity = int(capacity)
+        self.items: List[MemoryItem] = []
+        self.step = 0
+
+    @torch.no_grad()
+    def compute_protect_score(self, y: torch.Tensor, logits: torch.Tensor) -> torch.Tensor:
+        probs = F.softmax(logits, dim=1)
+        p_true = probs.gather(1, y.view(-1, 1)).squeeze(1)
+
+        loss_proxy = (-torch.log(p_true + 1e-8))
+        top2 = torch.topk(probs, k=2, dim=1).values
+        margin = (top2[:, 0] - top2[:, 1]).clamp(min=0.0)
+
+        loss_n = (loss_proxy / (loss_proxy.max() + 1e-8)).clamp(0, 1)
+        margin_n = (1.0 - (margin / (margin.max() + 1e-8))).clamp(0, 1)
+
+        score = 0.6 * loss_n + 0.4 * margin_n
+        return score.clamp(0, 1)
+
+    def add_batch(self, x: torch.Tensor, y: torch.Tensor, score: torch.Tensor) -> None:
+        x = x.detach().cpu()
+        y = y.detach().cpu()
+        score = score.detach().cpu()
+
+        for i in range(x.size(0)):
+            self.items.append(
+                MemoryItem(
+                    x=x[i],
+                    y=int(y[i]),
+                    protect_score=float(score[i].item()),
+                    seen_step=self.step,
+                )
+            )
+            self.step += 1
+
+        if len(self.items) > self.capacity:
+            self.items.sort(key=lambda it: it.protect_score, reverse=True)
+            self.items = self.items[: self.capacity]
+
+    def sample(
+        self,
+        n: int = 64,
+        device: Optional[torch.device] = None,
+    ) -> Optional[Tuple[torch.Tensor, torch.Tensor]]:
+        if not self.items:
+            return None
+
+        n = min(int(n), len(self.items))
+        idx = np.random.choice(len(self.items), size=n, replace=False)
+
+        xs = torch.stack([self.items[i].x for i in idx])
+        ys = torch.tensor([self.items[i].y for i in idx], dtype=torch.long)
+
+        if device is not None:
+            xs = xs.to(device)
+            ys = ys.to(device)
+
+        return xs, ys
+
+    def stats(self) -> Dict[str, float]:
+        if not self.items:
+            return {"size": 0.0, "avg_score": 0.0, "p90_score": 0.0}
+
+        scores = np.array([it.protect_score for it in self.items], dtype=float)
+        return {
+            "size": float(len(self.items)),
+            "avg_score": float(scores.mean()),
+            "p90_score": float(np.percentile(scores, 90)),
+        }

memorysafe-0.1.0/src/memorysafe.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: memorysafe
+Version: 0.1.0
+Summary: MemorySafe: MVI-driven memory governance for continual learning systems.
+Author: Carla P. Centeno
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: mvi-metrics
+Requires-Dist: numpy
+Dynamic: license-file

memorysafe-0.1.0/src/memorysafe.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/memorysafe/__init__.py
+src/memorysafe/buffer.py
+src/memorysafe/demo.py
+src/memorysafe.egg-info/PKG-INFO
+src/memorysafe.egg-info/SOURCES.txt
+src/memorysafe.egg-info/dependency_links.txt
+src/memorysafe.egg-info/requires.txt
+src/memorysafe.egg-info/top_level.txt

memorysafe-0.1.0/src/memorysafe.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

memorysafe-0.1.0/src/memorysafe.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mvi-metrics
+numpy

memorysafe-0.1.0/src/memorysafe.egg-info/top_level.txt

@@ -0,0 +1 @@
+memorysafe