memorysafe 0.1.0__py3-none-any.whl

memorysafe/__init__.py

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

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+memorysafe/__init__.py,sha256=KcSUwIvlc0YX4mh67CsZsyuQA0CoaGZgQeoouGMzBo8,117
+memorysafe/buffer.py,sha256=Vs720tsYK84AjUreHbZaN84tPuAEGwh51nPIjWbRg2c,2830
+memorysafe/demo.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memorysafe-0.1.0.dist-info/licenses/LICENSE,sha256=IcOH5RGd5Sd4PIdCEkPpG-ibb5qoP_R4DMTdKjoZ2bk,634
+memorysafe-0.1.0.dist-info/METADATA,sha256=FJBfwHJ5_N55B5XwJRbksJXTa9Oh1yGwLNMKZEKdkw0,290
+memorysafe-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+memorysafe-0.1.0.dist-info/top_level.txt,sha256=8vY8F97skgmHRq2AfHyyp9NUuyO8mBoD6RZLB-nf7_c,11
+memorysafe-0.1.0.dist-info/RECORD,,

memorysafe-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

memorysafe-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

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