untested run_test.py code, committing to try on another system

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 *.logits.safetensors filter=lfs diff=lfs merge=lfs -text
+*.logits-and-weights.safetensors filter=lfs diff=lfs merge=lfs -text

_safetensors.py

@@ -0,0 +1,70 @@
+# ran into memory issues with safetensors. this code moves by them.
+import contextlib, os
+
+class WritingSafeTensors:
+    def __init__(self, filename, **metadata):
+        self.filename = filename
+        self.fd = os.open(self.filename, os.O_RDWR | os.O_CREAT)
+        self.size = 0
+        self.capacity = 0
+        self.mmapview = None
+        self.header = {'__metadata__': metadata}
+    def _reserve(self, length):
+        if self.size + length > self.capacity:
+            new_capacity = self.size * 2
+            if new_capacity < self.size + length:
+                new_capacity = (((self.size + length)*2 - 1) // mmap.PAGESIZE + 1) * mmap.PAGESIZE
+                os.truncate(self.fn, new_capacity)
+            self.mmapview = memoryview(mmap.mmap(self.fd, new_capacity))
+            self.capacity = new_capacity
+    def add(self, name, tensor):
+        print(name, '...')
+        length = tensor.numel() * tensor.dtype.itemsize
+        self._reserve(length)
+        torch.frombuffer(
+                self.mmapview[self.size:self.size+length],
+                dtype=tensor.dtype, count=tensor.numel,
+        ).view(tensor.shape)[:] = tensor
+        end = self.size + length
+        self.header[descr] = {
+            'dtype': 
+                str(tensor.dtype).rsplit('.',1)[-1]
+                    .replace('float','F')
+                    .replace('uint','U')
+                    .replace('int','I')
+                    .removesuffix('fn')
+                    .upper(),
+            'shape':
+                list(tensor.shape),
+            'data_offsets':
+                [self.size, end],
+        }
+        self.size = end
+    def finalize(self):
+        print(self.filename, '...')
+        import pdb; pdb.set_trace()
+        header = json.dumps(self.header).encode()
+        insert = len(header) + 8
+        self._reserve(insert)
+        self.mmapview[insert:insert+self.size] = self.mmapview[:self.size]
+        self.size += insert
+        self[:8] = len(header).to_bytes(8, 'little')
+        self[8:insert] = header
+        del self.header
+        del self.mmapview
+        os.close(self.fd)
+        os.truncate(self.filename, self.size)
+    def delete(self):
+        print('deleting', self.filename, '...')
+        del self.header
+        del self.mmapview
+        os.close(self.fd)
+        os.unlink(self.filename)
+    def __enter__(self):
+        return self
+    def __exit__(self, Exc, exc, tb):
+        if Exc is None:
+            self.finalize()
+        else:
+            self.delete()
+

compare_safetensors.py

@@ -11,6 +11,7 @@ def compare(*fns):
     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: [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]]
     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 ...')
@@ -20,6 +21,7 @@ def compare(*fns):
     mismatching_keys = [k for k, d in dists.items() if (d!=0).any()]
 
     print(f'{len(mismatching_keys)/len(files[0].keys())*100:.2f}% keys mismatch')
+    print(f'{len(mismatching_dtypes)/len(files[0].keys())*100:.2f}% dtypes mismatch')
 
     #errs = {k:(dists[k] / avgs[k]).nan_to_num() for k in files[0].keys()}
 
@@ -45,7 +47,10 @@ def compare(*fns):
                 print('.. ', end='')
             for idx in range_:
                 for token in range(head_tokens.values.shape[-2]):
-                    print(f'{head_tokens.indices[token,idx]}({head_tokens.values[token,idx]*100:.2f}%) ',end='')
+                    if range_idx == 0:
+                        print(f'{head_tokens.indices[token][idx]}({head_tokens.values[token][idx]*100:.3f}%) ',end='')
+                    else: # the % format changes from f to e to show smaller values
+                        print(f'{head_tokens.indices[token][idx]}({head_tokens.values[token][idx]*100:.3e}%) ',end='')
         print()
 
 

run_test.py

@@ -1,9 +1,13 @@
 #!/usr/bin/env python3
-import os, sys
+import mmap, os, sys
 
 STORE_WEIGHTS = False
+FAKE_H100 = False
+TORCH_DTYPE = 'float64'
+USE_GPU = False
 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'
 
 import torch, numpy as np, random
@@ -17,7 +21,11 @@ os.environ['CUDA_LAUNCH_BLOCKING'] = '1'
 torch.manual_seed(0)
 random.seed(0)
 np.random.seed(0)
+if FAKE_H100:
+    torch.cuda.is_available = lambda: True
+    torch.cuda.get_device_capability = lambda: [9,0]
 import accelerate, safetensors.torch, transformers, tqdm
+from _safetensors import WritingSafeTensors
 
 config = transformers.AutoConfig.from_pretrained(model_id, revision=revision, trust_remote_code=True)
 tokenizer = transformers.AutoTokenizer.from_pretrained(model_id, revision=revision, trust_remote_code=True)
@@ -26,18 +34,35 @@ if config.model_type == 'deepseek_v3':
     #Model = transformers.DeepseekV3ForCausalLM
     pass
 
-model = Model.from_pretrained(model_id, revision=revision, trust_remote_code=True, torch_dtype=torch.float64, use_safetensors=True, low_cpu_mem_usage=True,
-        device_map='auto', max_memory={'cpu':accelerate.utils.get_max_memory()['cpu']}, offload_state_dict=True, offload_buffers=True)
+max_memory = accelerate.utils.get_max_memory()
+if not USE_GPU:
+    max_memory = {'cpu': max_memory['cpu']}
+max_memory['cpu'] //= 3
+model = Model.from_pretrained(model_id, revision=revision, trust_remote_code=True,
+    torch_dtype=getattr(torch, TORCH_DTYPE, TORCH_DTYPE), use_safetensors=True, low_cpu_mem_usage=True,
+    device_map='auto', max_memory=max_memory, offload_state_dict=True, offload_buffers=True)
 
 if config.model_type == 'deepseek_v3':
     model._supports_cache_class = False
-#model = accelerate.cpu_offload(model, 'cuda:0', offload_buffers=True)
 
 pipe = transformers.pipeline('text-generation', model=model, config=config, tokenizer=tokenizer)
 
-tensors = {}
-def store_tensor(descr, tensor):
-    tensors[descr] = tensor.cpu().detach().contiguous().clone()
+SafeTensors = WritingSafeTensors(
+        fn,
+        prompt = prompt,
+        model_id = model_id,
+        revision = revision,
+        weights = STORE_WEIGHTS,
+        torch_dtype = TORCH_DTYPE,
+        gpu = USE_GPU,
+        **{
+            f'{hw}:{idx}':
+                str(getattr(torch, hw).get_device_properties(idx))
+            for hw in ['npu','mlu','musa','xpu','cuda']
+                if hasattr(torch, hw)
+                    for idx in range(getattr(torch,hw).device_count())
+        }
+    )
 
 IDX = 0 # IDX is unused
 module_names = {mod:name for name, mod in pipe.model.named_modules()}
@@ -45,25 +70,29 @@ tensors = {}
 def hook(module, inputs, outputs):
     global IDX
     name = module_names[module]
+    HAS_HF_HOOK = hasattr(module, '_hf_hook')
+    if HAS_HF_HOOK:
+        inputs = module._hf_hook.pre_forward(module, *inputs)
     for idx, input in enumerate(inputs):
         if isinstance(input, torch.Tensor):
             store_tensor(f'{name}.input.{idx}', input);
+    if STORE_WEIGHTS and not list(module.children()):
+        for wtname, wt in list(module.named_parameters()) + list(module.named_buffers()):
+            store_tensor(f'{name}.{wtname}', wt)
+    if HAS_HF_HOOK:
+        outputs = module._hf_hook.post_forward(module, outputs)
     if isinstance(outputs, torch.Tensor):
         store_tensor(f'{name}.output', outputs);
     else:
         for idx, output in enumerate(outputs):
             if isinstance(output, torch.Tensor):
                 store_tensor(f'{name}.output.{idx}', output);
-    if STORE_WEIGHTS and not list(module.children()):
-        for wtname, wt in list(module.named_parameters()) + list(module.named_buffers()):
-            store_tensor(f'{name}.{wtname}', wt)
     IDX += 1
 
 for module in pipe.model.modules():
     module.register_forward_hook(hook)
 
-prompt = 'Once upon a time,'
-output = pipe(prompt, do_sample=False, max_new_tokens=1, temperature=1.0, top_p=1.0)
-safetensors.torch.save_file(tensors, fn, dict(prompt=prompt))
+with SafeTensors:
+    output = pipe(prompt, do_sample=False, max_new_tokens=1, temperature=1.0, top_p=1.0)
 print()
 print(output)