added more input/output datas and drafted deduplicating tensor hash code. may not run have run into issues detering testing agian.

_bighash.py

@@ -0,0 +1,91 @@
+import torch
+
+# xxhash primes converted to int64
+XXPRIME_1 = -(11400714785074694791 ^ 0xffffffffffffffff) - 1
+XXPRIME_2 = -(14029467366897019727 ^ 0xffffffffffffffff) - 1
+XXPRIME_5 = 2870177450012600261
+# python tuple value
+XXPRIME_5_3527539 = XXPRIME_5 ^ 3527539
+
+def tensor_python_tuple_hash(items, out_or_in_place):
+    # https://github.com/python/cpython/blob/v3.13.2/Objects/tupleobject.c#L321
+    # this is apparently a simplified & modified form of xxhash
+    # learning xxhash could likely improve the code in this file
+
+    len_ = len(items)
+    # first iteration pulled out to provide storage placement
+    if out_or_in_place is None:
+        # in place
+        acc = torch.add(XXPRIME_5, items[0], alpha=XXPRIME_2, out=items[0])
+    else:
+        # place in out_or_in_place
+        acc = torch.add(XXPRIME_5, items[0], alpha=XXPRIME_2, out=out_or_in_place)
+    # bitwise rotation
+    upshift = acc << 31
+    acc >>= 33
+    acc &= 0x7fffffff # mask int64 sign extension
+    acc |= upshift
+
+    acc *= XXPRIME_1
+
+    for i in range(1, len_):
+        # acc += x * prime2
+        acc.add_(items[i], alpha=XXPRIME_2)
+
+        # bitwise rotation
+        upshift = acc << 31
+        acc >>= 33
+        acc &= 0x7fffffff # mask int64 sign extension
+        acc |= upshift
+
+        acc *= XXPRIME_1
+
+    acc += (len_ ^ XXPRIME_5_3527539)
+    return acc
+
+def hash(buffer, *incoming_unhashed_ints):
+    if len(buffer) < 16:
+        return buffer.__hash__()
+
+    # first pass
+    # - allocate storage
+    # - place unhashed ints
+
+    words = len(buffer) // 8
+    dwords = words // 2
+    incoming_data = torch.frombuffer(buffer, count=words, dtype=torch.int64)
+    incoming_unhashed_ints = [int.from_bytes(buffer[words*8:],'little')] + list(incoming_unhashed_ints)
+
+    incoming_hashable_length = words & ~1
+    incoming_unhashed_length = words & 1
+    incoming_unhashed_int_length = len(incoming_unhashed_ints)
+    incoming_hashable_data = incoming_data[:incoming_hashable_length].view(2,-1)
+    incoming_unhashed_data = incoming_data[incoming_hashable_length:]
+
+    storage = torch.empty([dwords + incoming_unhashed_length + incoming_unhashed_int_length], dtype=torch.int64)
+    hashed_data = tensor_python_tuple_hash(incoming_hashable_data, out_or_in_place=storage[:dwords])
+    storage[dwords:-incoming_unhashed_int_length] = incoming_unhashed_data
+    for idx in range(incoming_unhashed_int_length):
+        storage[dwords+idx] = incoming_unhashed_ints[idx]
+
+    incoming_data = storage
+    words = len(incoming_data)
+    dwords = words // 2
+
+    # iterative passes
+    while words > 1:
+        incoming_hashable_length = words & ~1
+        incoming_unhashed_length = words & 1
+        incoming_hashable_data = incoming_data[:incoming_hashable_length].view(2,-1)
+        incoming_unhashed_tensor_data = incoming_data[incoming_hashable_length:]
+
+        hashed_data = tensor_python_tuple_hash(incoming_hashable_data, out_or_in_place=None)
+        words = dwords + incoming_unhashed_length
+        storage[dwords:words] = incoming_unhashed_tensor_data
+        incoming_data = storage[:words]
+        dwords = words // 2
+        
+    return incoming_data[0].item()
+
+if __name__ == '__main__':
+    print(hash(bytearray(b'the quick brown fox jumped over the lazy dog')))

_safetensors.py

@@ -3,6 +3,8 @@ import contextlib, json, mmap, os
 
 import torch
 
+from _bighash import hash
+
 class WritingSafeTensors:
     def __init__(self, name, file_size=16*1024*1024*1024, **metadata):
         self.name = name.removesuffix('.safetensors')
@@ -10,36 +12,41 @@ class WritingSafeTensors:
         self.file = self.File(self.name + '.safetensors')
         self.files = {self.file.filename:self.file}
         self.file_size = file_size
-        self.total_size = 0
         self.weight_map = {}
+        self.hash_map = {}
     def add(self, name, tensor):
         print(name, '...')
-        self.weight_map[name] = self.file
-        self.file.add(name, tensor)
-        if self.file.size >= self.file_size:
+        tensor_hash = self.file.add(name, tensor)
+        image_of = self.hash_map.get(tensor_hash)
+        if image_of is not None:
+            self.file.undo(name, tensor)
+            imaged_hash = self.weight_map[image_of].add(name, tensor, image_of)
+            assert imaged_hash == tensor_hash
+        elif self.file.size >= self.file_size:
             self.file.undo(name, tensor)
             ct = len(self.files)
             if len(self.files) == 1:
                 self.file.rename(f'{self.name}-{ct:05}.safetensors')
                 self.file.set_metadata(index = str(ct))
                 self.files = {self.file.filename:self.file}
-            self.file.finalize()
-            self.total_size += self.file.size
             ct += 1
             self.file = self.File(f'{self.name}-{ct:05}.safetensors', index = ct)
             self.files[self.file.filename] = self.file
             self.file.add(name, tensor)
             self.weight_map[name] = self.file
     def finalize(self):
-        self.file.finalize()
-        if len(self.files) > 1:
-            self.total_size += self.file.size
+        if len(self.files) == 1:
+            self.file.finalize()
+        else:
             index_name = self.name + '.safetensors.index.json'
             print(index_name, '...')
+            total_size = 0
             tot = len(self.files)
             for ct, file in enumerate(self.files.values()):
                 ct += 1
                 file.rename(f'{self.name}-{ct:05}-of-{tot:06}.safetensors')
+                file.finalize()
+                total_size += file.size
             with open(index_name, 'w') as fh:
                 json.dump(
                     {
@@ -82,6 +89,7 @@ class WritingSafeTensors:
         
     class File:
         def __init__(self, filename, **metadata):
+            print(filename, '...')
             self.filename = filename
             self.fd = os.open(self.filename, os.O_RDWR | os.O_CREAT)
             self.size = 0
@@ -97,28 +105,43 @@ 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):
+        def add(self, name, tensor, image_of=None):
             length = tensor.numel() * tensor.dtype.itemsize
-            self._reserve(length)
-            end = self.size + length
-            torch.frombuffer(
-                    self.mmapview[self.size:end],
-                    dtype=tensor.dtype, count=tensor.numel(),
-            ).view(tensor.shape)[:] = tensor
+            if image_of is None:
+                self._reserve(length)
+                start, end = self.size, self.size + length
+                torch.frombuffer(
+                        self.mmapview[start : end],
+                        dtype=tensor.dtype, count=tensor.numel(),
+                ).view(tensor.shape or [1])[:] = tensor
+            else:
+                image = self.header[image_of]
+                start, end = image['data_offsets']
+                assert end - start == length
+                assert (tensor == torch.frombuffer(
+                        self.mmapview[start : end],
+                        dtype=tensor.dtype, count=tensor.numel(),
+                ).view(tensor.shape or [1])[:]).all()
+
+            tensor.flatten()
+            tensor_hash = hash(self.mmapview[start : end])
+
             self.header[name] = {
                 'dtype': 
                     str(tensor.dtype).rsplit('.',1)[-1]
                         .replace('float','F')
                         .replace('uint','U')
                         .replace('int','I')
+                        .removesuffix('uz')
                         .removesuffix('fn')
                         .upper(),
                 'shape':
                     list(tensor.shape),
                 'data_offsets':
-                    [self.size, end],
+                    [start, end],
             }
             self.size = end
+            return tensor_hash
         def undo(self, name, tensor):
             length = tensor.numel() * tensor.dtype.itemsize
             del self.header[name]
@@ -153,4 +176,3 @@ class WritingSafeTensors:
                 os.close(self.fd)
                 self.finalized = True
             os.unlink(self.filename)
-

run_test.py

@@ -67,33 +67,45 @@ SafeTensors = WritingSafeTensors(
 IDX = 0 # IDX is unused
 module_prefixes = {mod : name + '.' if name else '' for name, mod in pipe.model.named_modules()}
 tensors = {}
+def add_if_tensor(name, tensor):
+    if not isinstance(tensor, torch.Tensor):
+        try:
+            tensor = torch.tensor(tensor)
+        except:
+            try:
+                for idx, subtensor in enumerate(tensor):
+                    add_if_tensor(f'{name}.{idx}', subtensor)
+            except:
+                pass
+            return
+    SafeTensors.add(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)
     for idx, input in enumerate(inputs):
-        if isinstance(input, torch.Tensor):
-            SafeTensors.add(f'{prefix}input.{idx}', input);
+        add_if_tensor(f'{prefix}input.{idx}', input);
     for key, input in kwinputs.items():
-        if isinstance(input, torch.Tensor):
-            SafeTensors.add(f'{prefix}input.{key}', input);
-    if STORE_WEIGHTS and not list(module.children()):
-        for wtname, wt in list(module.named_parameters()) + list(module.named_buffers()):
-            SafeTensors.add(f'{prefix}{wtname}', wt)
+        add_if_tensor(f'{prefix}input.{key}', input);
+    if STORE_WEIGHTS:
+        for wtname, wt in module.named_buffers(recurse=False):
+            add_if_tensor(f'{prefix}{wtname}', wt)
+        for wtname, wt in module.named_parameters(recurse=False):
+            add_if_tensor(f'{prefix}{wtname}', wt)
     if HAS_HF_HOOK:
         outputs = module._hf_hook.post_forward(module, outputs)
     if isinstance(outputs, torch.Tensor):
-        SafeTensors.add(f'{prefix}output', outputs);
+        add_if_tensor(f'{prefix}output', outputs);
     elif isinstance(outputs, dict):
         for key, output in outputs.items():
-            if isinstance(output, torch.Tensor):
-                SafeTensors.add(f'{prefix}output.{key}', output);
+            add_if_tensor(f'{prefix}output.{key}', output);
     else:
         for idx, output in enumerate(outputs):
-            if isinstance(output, torch.Tensor):
-                SafeTensors.add(f'{prefix}output.{idx}', output);
+            add_if_tensor(f'{prefix}output.{idx}', output);
     IDX += 1
 
 for module in pipe.model.modules():