deduplication bugfixes. turns out safetensors does not support deduplicated tensor files.

_safetensors.py

@@ -1,30 +1,35 @@
 # ran into memory issues with safetensors. this code moves by them.
-import contextlib, json, mmap, os
+import contextlib, json, mmap, os, warnings
 
 import torch
 
 from _bighash import hash
 
 class WritingSafeTensors:
-    def __init__(self, name, file_size=16*1024*1024*1024, **metadata):
+    def __init__(self, name, file_size=16*1024*1024*1024, deduplicate=False, **metadata):
         self.name = name.removesuffix('.safetensors')
         self.metadata = metadata
         self.file = self.File(self.name + '.safetensors')
         self.files = {self.file.filename:self.file}
         self.file_size = file_size
         self.weight_map = {}
-        self.hash_map = {}
+        if deduplicate:
+            warnings.warn('Safetensors deduplication enabled. The file will not be readable with the official library without https://github.com/huggingface/safetensors/pull/586', stacklevel=2)
+        self.hash_map = {} if deduplicate else None
     def add(self, name, tensor):
-        tensor_hash = self.file.add(name, tensor)
-        image_of = self.hash_map.setdefault(tensor_hash, name)
+        if self.hash_map is None:
+            self.file.add(name, tensor, return_hash=False)
+            image_of = name
+        else:
+            tensor_hash = self.file.add(name, tensor, return_hash=True)
+            image_of = self.hash_map.setdefault(tensor_hash, name)
         if image_of is not name:
-            self.file.undo(name, tensor, True)
-            imaged_hash = self.weight_map[image_of].add(name, tensor, image_of)
-            assert imaged_hash == tensor_hash
+            self.file.undo(name, tensor)
+            self.weight_map[image_of].add(name, tensor, return_hash=False, image_of=image_of)
         else:
             print(name, '...')
             if self.file.size >= self.file_size:
-                self.file.undo(name, tensor, False)
+                self.file.undo(name, tensor)
                 ct = len(self.files)
                 if len(self.files) == 1:
                     self.file.rename(f'{self.name}-{ct:05}.safetensors')
@@ -106,7 +111,7 @@ class WritingSafeTensors:
                 os.truncate(self.filename, new_capacity)
                 self.mmapview = memoryview(mmap.mmap(self.fd, new_capacity))
                 self.capacity = new_capacity
-        def add(self, name, tensor, image_of=None):
+        def add(self, name, tensor, return_hash, image_of=None):
             length = tensor.numel() * tensor.dtype.itemsize
             if image_of is None:
                 self._reserve(length)
@@ -115,6 +120,7 @@ class WritingSafeTensors:
                         self.mmapview[start : end],
                         dtype=tensor.dtype, count=tensor.numel(),
                 ).view(tensor.shape or [1])[:] = tensor
+                #assert len(self.header)<2 or max(list(self.header.items())[1:], key=lambda item:item[1]['data_offsets'])[1]['data_offsets'][-1] == self.size
                 assert end >= self.size
                 self.size = end
             else:
@@ -127,7 +133,10 @@ class WritingSafeTensors:
                 ).view(tensor.shape)).all()
 
             tensor.flatten()
-            tensor_hash = hash(self.mmapview[start : end])
+            if return_hash:
+                tensor_hash = hash(self.mmapview[start : end])
+            else:
+                tensor_hash = None
 
             self.header[name] = {
                 'dtype': 
@@ -144,12 +153,18 @@ class WritingSafeTensors:
                     [start, end],
             }
             return tensor_hash
-        def undo(self, name, tensor, is_image):
-            if not is_image:
-                length = tensor.numel() * tensor.dtype.itemsize
-                assert [self.size - length, self.size] == self.header[name]['data_offsets']
-                self.size -= length
+        def undo(self, name, tensor):
+            last_name = None
+            last_header = None
+            #max_name, max_header = max(list(self.header.items())[1:], key = lambda item: item[1]['data_offsets'][-1])
+            #assert max_name == name
+            #assert max_header['data_offsets'][-1] == self.size
+            length = tensor.numel() * tensor.dtype.itemsize
+            assert [self.size - length, self.size] == self.header[name]['data_offsets']
+            self.size -= length
             del self.header[name]
+            #max_name, max_header = max(list(self.header.items())[1:], key = lambda item: item[1]['data_offsets'][-1])
+            #assert max_header['data_offsets'][-1] == self.size
         def set_metadata(self, **metadata):
             m = self.header['__metadata__']
             for k, v in metadata.items():

run_test.py

@@ -2,6 +2,7 @@
 import os, sys
 
 STORE_WEIGHTS = False
+DEDUPLICATE_SAFETENSORS = True
 FAKE_H100 = False
 TORCH_DTYPE = 'float64'
 USE_GPU = False
@@ -9,7 +10,7 @@ DEVICE_MAP = 'auto'
 model_id, revision = sys.argv[1:]
 user, model = model_id.split('/')
 prompt = 'Once upon a time,'
-fn = f'{user}_{model}_{revision}.{"logits-and-weights" if STORE_WEIGHTS else "logits"}.safetensors'
+fn = f'{user}_{model}_{revision}.{"logits-and-weights" if STORE_WEIGHTS else "logits"}.{"DEDUPLICATED.safetensors" if DEDUPLICATE_SAFETENSORS else "safetensors"}'
 
 import torch, numpy as np, random
 torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction = False
@@ -51,6 +52,7 @@ pipe = transformers.pipeline('text-generation', model=model, config=config, toke
 
 SafeTensors = WritingSafeTensors(
         fn,
+        deduplicate = DEDUPLICATE_SAFETENSORS,
         prompt = prompt,
         store_weights = STORE_WEIGHTS,
         use_gpu = USE_GPU,
@@ -82,8 +84,6 @@ def add_if_tensor(name, tensor):
 def hook(module, inputs, kwinputs, outputs):
     global IDX
     prefix = module_prefixes[module]
-    if not prefix:
-        import pdb; pdb.set_trace()
     HAS_HF_HOOK = hasattr(module, '_hf_hook')
     if HAS_HF_HOOK:
         inputs, kwinputs = module._hf_hook.pre_forward(module, *inputs, **kwinputs)

scripts/compare_safetensors.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-import safetensors
+import safetensors.torch, torch # any tensor library would work
 
 def compare(*fns):
     global files, mismatching_keys, avgs, dists, errs
@@ -9,13 +9,14 @@ def compare(*fns):
     assert set(files[0].keys()) == set(files[1].keys())
 
     print('dtypes ...')
-    dtypes = {k: [files[0].get_slice(k)[0].dtype,files[1].get_slice(k)[0].dtype] for k in files[0].keys()}
+    dtypes = {k: [safetensors.torch._TYPES[file.get_slice(k).get_dtype()] for file in files] for k in files[0].keys()}
     dtypes = {k: [min(dts, key=lambda dt: dt.itemsize),max(dts, key=lambda dt: dt.itemsize)] for k, dts in dtypes.items()}
     mismatching_dtypes = [k for k, dts in dtypes.items() if dts[0] is not dts[1]]
+    cmp_dtypes = {k: torch.int8 if dts[0] is torch.bool else dts[0] for k, dts in dtypes.items()}
     print('midpoints ...')
     avgs = {k:((files[0].get_tensor(k) + files[1].get_tensor(k))/2).to(dtypes[k][0]) for k in files[0].keys()}
     print('dists ...')
-    dists = {k:(files[0].get_tensor(k).to(dtypes[k][0]) - files[1].get_tensor(k).to(dtypes[k][0])).abs() for k in files[0].keys()}
+    dists = {k:(files[0].get_tensor(k).to(cmp_dtypes[k]) - files[1].get_tensor(k).to(cmp_dtypes[k])).abs() for k in files[0].keys()}
 
     print('keys ...')
     mismatching_keys = [k for k, d in dists.items() if (d!=0).any()]