Upload convert_to_gguf_pure.py with huggingface_hub

convert_to_gguf_pure.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+Convert pure Python DGPO model to GGUF format.
+Usage: python3 convert_to_gguf_pure.py
+"""
+
+import os
+import struct
+import pickle
+import numpy as np
+
+# GGUF constants
+GGUF_MAGIC = 0x46475546  # "GGUF"
+GGUF_VERSION = 3
+
+# GGML types
+GGML_TYPE_F32 = 0
+GGML_TYPE_F16 = 1
+
+# Tensor types mapping
+DTYPE_MAP = {
+    np.dtype('float32'): GGML_TYPE_F32,
+    np.dtype('float64'): GGML_TYPE_F32,
+}
+
+class GGUFWriter:
+    """Minimal GGUF file writer."""
+
+    def __init__(self, path):
+        self.path = path
+        self.metadata = {}
+        self.tensors = []
+
+    def add_metadata(self, key, value):
+        """Add metadata key-value pair."""
+        self.metadata[key] = value
+
+    def add_tensor(self, name, data):
+        """Add a tensor."""
+        if not isinstance(data, np.ndarray):
+            data = np.array(data, dtype=np.float32)
+        else:
+            data = data.astype(np.float32)
+        self.tensors.append((name, data))
+
+    def write(self):
+        """Write GGUF file."""
+        with open(self.path, 'wb') as f:
+            # Header
+            f.write(struct.pack('<I', GGUF_MAGIC))
+            f.write(struct.pack('<I', GGUF_VERSION))
+
+            # Tensor count
+            f.write(struct.pack('<Q', len(self.tensors)))
+
+            # Metadata count
+            f.write(struct.pack('<Q', len(self.metadata)))
+
+            # Write metadata
+            for key, value in self.metadata.items():
+                self._write_string(f, key)
+                self._write_metadata_value(f, value)
+
+            # Calculate data offset (after header + metadata + tensor info)
+            header_size = 4 + 4 + 8 + 8  # magic + version + tensor_count + metadata_count
+            metadata_size = 0
+            for key, value in self.metadata.items():
+                metadata_size += 2 + len(key)  # key length + key
+                metadata_size += self._metadata_value_size(value)
+
+            tensor_info_size = 0
+            for name, data in self.tensors:
+                tensor_info_size += 2 + len(name)  # name length + name
+                tensor_info_size += 4  # ndim
+                tensor_info_size += data.ndim * 8  # shape
+                tensor_info_size += 4  # dtype
+                tensor_info_size += 8  # offset
+
+            alignment = 32
+            data_offset = header_size + metadata_size + tensor_info_size
+            padded_offset = ((data_offset + alignment - 1) // alignment) * alignment
+
+            # Write tensor info
+            current_offset = 0
+            for name, data in self.tensors:
+                self._write_string(f, name)
+                f.write(struct.pack('<I', data.ndim))
+                for dim in data.shape:
+                    f.write(struct.pack('<Q', dim))
+                f.write(struct.pack('<I', GGML_TYPE_F32))
+                f.write(struct.pack('<Q', padded_offset + current_offset))
+                current_offset += data.nbytes
+
+            # Pad to alignment
+            f.write(b'\x00' * (padded_offset - (header_size + metadata_size + tensor_info_size)))
+
+            # Write tensor data
+            for name, data in self.tensors:
+                f.write(data.tobytes())
+
+        print(f"Written GGUF: {self.path}")
+        print(f"  Tensors: {len(self.tensors)}")
+        print(f"  Size: {os.path.getsize(self.path) / 1024:.1f} KB")
+
+    def _write_string(self, f, s):
+        """Write a string."""
+        encoded = s.encode('utf-8')
+        f.write(struct.pack('<Q', len(encoded)))
+        f.write(encoded)
+
+    def _write_metadata_value(self, f, value):
+        """Write a metadata value."""
+        if isinstance(value, str):
+            # String type = 8
+            f.write(struct.pack('<I', 8))
+            encoded = value.encode('utf-8')
+            f.write(struct.pack('<Q', len(encoded)))
+            f.write(encoded)
+        elif isinstance(value, int):
+            # UINT64 type = 10
+            f.write(struct.pack('<I', 10))
+            f.write(struct.pack('<Q', value))
+        elif isinstance(value, float):
+            # FLOAT64 type = 13
+            f.write(struct.pack('<I', 13))
+            f.write(struct.pack('<d', value))
+        elif isinstance(value, bool):
+            # BOOL type = 6
+            f.write(struct.pack('<I', 6))
+            f.write(struct.pack('<?', value))
+        elif isinstance(value, list):
+            # Array type = 9
+            f.write(struct.pack('<I', 9))
+            if value and isinstance(value[0], str):
+                f.write(struct.pack('<I', 8))  # String array
+                f.write(struct.pack('<Q', len(value)))
+                for s in value:
+                    encoded = s.encode('utf-8')
+                    f.write(struct.pack('<Q', len(encoded)))
+                    f.write(encoded)
+            else:
+                f.write(struct.pack('<I', 10))  # UINT64 array
+                f.write(struct.pack('<Q', len(value)))
+                for v in value:
+                    f.write(struct.pack('<Q', v))
+
+    def _metadata_value_size(self, value):
+        """Calculate metadata value size."""
+        if isinstance(value, str):
+            return 4 + 8 + len(value.encode('utf-8'))
+        elif isinstance(value, (int, float, bool)):
+            return 4 + 8
+        elif isinstance(value, list):
+            size = 4 + 4 + 8
+            for v in value:
+                if isinstance(v, str):
+                    size += 8 + len(v.encode('utf-8'))
+                else:
+                    size += 8
+            return size
+        return 0
+
+def convert():
+    """Convert pure Python model to GGUF."""
+    model_path = "./dgpo-tiny-pure/dgpo_tiny.pkl"
+    output_path = "./dgpo-tiny-pure.gguf"
+
+    if not os.path.exists(model_path):
+        print(f"Model not found: {model_path}")
+        print("Run: python3 train_dgpo_pure.py")
+        return
+
+    print("=" * 50)
+    print("Converting to GGUF")
+    print("=" * 50)
+
+    # Load model
+    with open(model_path, "rb") as f:
+        model_data = pickle.load(f)
+
+    config = model_data["config"]
+    vocab_size, d_model, n_heads, n_layers, max_len = config
+
+    print(f"Model config: vocab={vocab_size}, d_model={d_model}, layers={n_layers}, heads={n_heads}")
+
+    # Create GGUF writer
+    writer = GGUFWriter(output_path)
+
+    # Add metadata
+    writer.add_metadata("general.architecture", "gpt2")
+    writer.add_metadata("general.name", "dgpo-tiny-pure")
+    writer.add_metadata("gpt2.context_length", max_len)
+    writer.add_metadata("gpt2.embedding_length", d_model)
+    writer.add_metadata("gpt2.block_count", n_layers)
+    writer.add_metadata("gpt2.head_count", n_heads)
+    writer.add_metadata("gpt2.vocab_size", vocab_size)
+
+    # Add tensors
+    # Embedding
+    embed = np.array(model_data["embed"], dtype=np.float32)
+    writer.add_tensor("token_embd.weight", embed)
+
+    # Position embedding
+    pos_embed = np.array(model_data["pos_embed"], dtype=np.float32)
+    writer.add_tensor("position_embd.weight", pos_embed)
+
+    # Transformer layers
+    for i, layer in enumerate(model_data["layers"]):
+        prefix = f"blk.{i}"
+
+        # Layer norm 1
+        writer.add_tensor(f"{prefix}.ln1.weight", np.array(layer["ln1_gamma"], dtype=np.float32))
+        writer.add_tensor(f"{prefix}.ln1.bias", np.array(layer["ln1_beta"], dtype=np.float32))
+
+        # Attention
+        writer.add_tensor(f"{prefix}.attn.q.weight", np.array(layer["wq"], dtype=np.float32).T)
+        writer.add_tensor(f"{prefix}.attn.k.weight", np.array(layer["wk"], dtype=np.float32).T)
+        writer.add_tensor(f"{prefix}.attn.v.weight", np.array(layer["wv"], dtype=np.float32).T)
+        writer.add_tensor(f"{prefix}.attn.o.weight", np.array(layer["wo"], dtype=np.float32).T)
+
+        # Layer norm 2
+        writer.add_tensor(f"{prefix}.ln2.weight", np.array(layer["ln2_gamma"], dtype=np.float32))
+        writer.add_tensor(f"{prefix}.ln2.bias", np.array(layer["ln2_beta"], dtype=np.float32))
+
+        # FFN
+        writer.add_tensor(f"{prefix}.ffn_up.weight", np.array(layer["w1"], dtype=np.float32).T)
+        writer.add_tensor(f"{prefix}.ffn_down.weight", np.array(layer["w2"], dtype=np.float32).T)
+
+    # Output
+    output_proj = np.array(model_data["output_proj"], dtype=np.float32)
+    writer.add_tensor("output.weight", output_proj.T)
+
+    # Write file
+    writer.write()
+
+    print("\n" + "=" * 50)
+    print(f"Done! GGUF: {output_path}")
+    print("=" * 50)
+
+if __name__ == "__main__":
+    convert()