Initial commit

safetensors2gguf.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Direct SafeTensors to GGUF converter for unsupported architectures.
+
+This script attempts to convert SafeTensors models to GGUF format directly,
+without relying on llama.cpp's architecture-specific conversion logic.
+"""
+
+from __future__ import annotations
+
+import sys
+import traceback
+from argparse import ArgumentParser
+from pathlib import Path
+
+from helpers.logger import logger
+from helpers.services.gguf import GGUFConverter
+from helpers.utils.config_parser import ConfigParser
+from helpers.utils.tensor_mapping import TensorMapper
+
+
+def convert_safetensors_to_gguf(
+    model_path: Path, output_path: Path, force_architecture: str | None = None
+) -> bool:
+    """Convert SafeTensors model to GGUF format with comprehensive metadata handling.
+
+    Orchestrates the complete conversion workflow: loads configuration, maps
+    architecture to known GGUF types, creates writer with proper metadata,
+    processes all tensor files with name mapping, and adds tokeniser data.
+    Handles BFloat16 conversion and provides fallback architecture mapping
+    for unsupported model types to ensure maximum compatibility.
+
+    Returns:
+        True if conversion was successful, False otherwise.
+    """
+    # Use ConfigParser to load configuration
+    config_parser = ConfigParser()
+    model_config = config_parser.load_model_config(model_path)
+
+    arch_name = model_config.architectures[0]
+    model_type = model_config.model_type
+
+    logger.info(f"Architecture: {arch_name}")
+    logger.info(f"Model type: {model_type}")
+
+    # Use forced architecture or try to map to a known one
+    if force_architecture:
+        arch = force_architecture
+        logger.warning(f"Using forced architecture: {arch}")
+    else:
+        # Use ConfigParser's architecture mapping
+        arch = config_parser.get_architecture_mapping(arch_name)
+        if arch != arch_name:
+            logger.warning(f"Unknown architecture {arch_name}, using {arch} as fallback")
+
+    # Use the new GGUFConverter for the conversion
+    tensor_mapper = TensorMapper()
+    return GGUFConverter.convert_safetensors(
+        model_path, output_path, model_config, arch, tensor_mapper
+    )
+
+
+def main() -> None:
+    """Main entry point for SafeTensors to GGUF conversion command-line interface.
+
+    Parses command-line arguments, validates input paths, and orchestrates the
+    conversion process with proper error handling. Supports forced architecture
+    mapping and flexible output path specification. Provides comprehensive
+    error reporting and exit codes for integration with automated workflows.
+    """
+    parser = ArgumentParser(description="Convert SafeTensors to GGUF directly")
+    parser.add_argument("model_path", help="Path to SafeTensors model directory")
+    parser.add_argument("-o", "--output", help="Output GGUF file path")
+    parser.add_argument("--force-arch", help="Force a specific architecture mapping")
+
+    args = parser.parse_args()
+
+    model_path = Path(args.model_path)
+    if not model_path.exists():
+        logger.error(f"Model path not found: {model_path}")
+        sys.exit(1)
+
+    output_path = Path(args.output) if args.output else model_path / f"{model_path.name}-f32.gguf"
+
+    try:
+        success = convert_safetensors_to_gguf(model_path, output_path, args.force_arch)
+        sys.exit(0 if success else 1)
+    except Exception as e:
+        logger.error(f"Conversion failed: {e}")
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()