Upload folder using huggingface_hub

app.py

@@ -7,7 +7,9 @@ import json
 import logging
 import subprocess
 import time
+import traceback
 from datetime import datetime
+from pathlib import Path
 
 # Configure logging to match HF Space logs
 logging.basicConfig(
@@ -36,17 +38,13 @@ CONFIG_DIR = "."
 TRANSFORMERS_CONFIG = os.path.join(CONFIG_DIR, "transformers_config.json")
 
 def load_config(config_path):
-    """Load configuration from JSON file."""
+    """Load configuration from a JSON file."""
     try:
-        if os.path.exists(config_path):
-            with open(config_path, 'r') as f:
-                return json.load(f)
-        else:
-            log_info(f"Config file not found: {config_path}")
-            return None
+        with open(config_path, 'r') as f:
+            return json.load(f)
     except Exception as e:
         log_info(f"Error loading config: {str(e)}")
-        return None
+        return {}
 
 def display_config():
     """Display current training configuration."""
@@ -174,7 +172,24 @@ def create_interface():
     return demo
 
 if __name__ == "__main__":
-    # If run directly, create and launch the Gradio interface
+    # Print basic system information to help with debugging
+    try:
+        import torch
+        logger.info(f"Python: {sys.version.split()[0]}")
+        logger.info(f"PyTorch: {torch.__version__}")
+        logger.info(f"CUDA available: {torch.cuda.is_available()}")
+        if torch.cuda.is_available():
+            logger.info(f"CUDA device: {torch.cuda.get_device_name(0)}")
+        
+        from transformers import __version__ as tf_version
+        logger.info(f"Transformers: {tf_version}")
+        
+        from unsloth import __version__ as un_version
+        logger.info(f"Unsloth: {un_version}")
+    except Exception as e:
+        logger.warning(f"Error printing system info: {e}")
+    
+    # Create and launch the Gradio interface
     demo = create_interface()
     demo.queue()
     demo.launch()

install.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+# coding=utf-8
+
+"""
+Installation script for Hugging Face Space setup.
+This script ensures all dependencies are installed correctly 
+during the Space build process.
+"""
+
+import os
+import sys
+import subprocess
+import logging
+import traceback
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger(__name__)
+
+def run_command(cmd, description=""):
+    """Run a shell command and log the output."""
+    logger.info(f"Running: {description if description else cmd}")
+    try:
+        process = subprocess.run(
+            cmd, 
+            shell=True, 
+            check=True,
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        logger.info(f"Command output: {process.stdout}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Command failed with exit code {e.returncode}")
+        logger.error(f"Error output: {e.stderr}")
+        return False
+
+def install_dependencies():
+    """Install all required dependencies in the correct order."""
+    current_dir = Path(__file__).parent
+    req_path = current_dir / "requirements.txt"
+    
+    if not req_path.exists():
+        logger.error(f"Requirements file not found: {req_path}")
+        return False
+    
+    try:
+        # Step 1: Upgrade pip
+        run_command(f"{sys.executable} -m pip install --upgrade pip", "Upgrading pip")
+        
+        # Step 2: Install direct torch version for CUDA compatibility
+        run_command(
+            f"{sys.executable} -m pip install torch>=2.0.0,<2.2.0 --extra-index-url https://download.pytorch.org/whl/cu118",
+            "Installing PyTorch with CUDA support"
+        )
+        
+        # Step 3: Install base dependencies
+        run_command(
+            f"{sys.executable} -m pip install transformers accelerate bitsandbytes peft einops",
+            "Installing ML dependencies"
+        )
+        
+        # Step 4: Install unsloth separately
+        run_command(
+            f"{sys.executable} -m pip install unsloth>=2024.3",
+            "Installing Unsloth"
+        )
+        
+        # Step 5: Install all remaining requirements
+        run_command(
+            f"{sys.executable} -m pip install -r {req_path}",
+            "Installing all requirements"
+        )
+        
+        # Verify critical packages
+        import_check = verify_imports()
+        if not import_check:
+            logger.error("Failed to verify critical packages")
+            return False
+        
+        logger.info("All dependencies installed successfully!")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error installing dependencies: {str(e)}")
+        traceback.print_exc()
+        return False
+
+def verify_imports():
+    """Verify that critical packages can be imported."""
+    critical_packages = [
+        "torch", "transformers", "unsloth", "peft", 
+        "gradio", "accelerate", "bitsandbytes"
+    ]
+    
+    success = True
+    for package in critical_packages:
+        try:
+            module = __import__(package)
+            version = getattr(module, "__version__", "unknown")
+            logger.info(f"Successfully imported {package} (version: {version})")
+        except ImportError:
+            logger.error(f"CRITICAL: Failed to import {package}")
+            success = False
+        except Exception as e:
+            logger.error(f"Error verifying {package}: {str(e)}")
+            success = False
+    
+    # Check CUDA
+    try:
+        import torch
+        cuda_available = torch.cuda.is_available()
+        device_count = torch.cuda.device_count() if cuda_available else 0
+        if cuda_available:
+            device_name = torch.cuda.get_device_name(0)
+            logger.info(f"CUDA available - Devices: {device_count}, Name: {device_name}")
+        else:
+            logger.warning(f"CUDA not available - This might affect performance")
+    except Exception as e:
+        logger.error(f"Error checking CUDA: {str(e)}")
+    
+    return success
+
+def main():
+    logger.info("Starting installation for Phi-4 Unsloth Training Space")
+    
+    try:
+        # Install dependencies
+        if not install_dependencies():
+            logger.error("Failed to install dependencies")
+            sys.exit(1)
+        
+        # Create marker file to show successful installation
+        with open("INSTALL_SUCCESS.txt", "w") as f:
+            f.write("Installation completed successfully")
+        
+        logger.info("Installation completed successfully")
+        return 0
+        
+    except Exception as e:
+        logger.error(f"Installation failed with error: {str(e)}")
+        traceback.print_exc()
+        return 1
+
+if __name__ == "__main__":
+    exit_code = main()
+    sys.exit(exit_code)