Upload InternVL2 implementation

Dockerfile

@@ -1,4 +1,4 @@
-FROM nvidia/cuda:11.8.0-cudnn8-devel-ubuntu22.04
+FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04
 
 # Set environment variables
 ENV DEBIAN_FRONTEND=noninteractive
@@ -25,7 +25,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     python3-pip \
     python3-dev \
     python3-setuptools \
-    nvidia-cuda-toolkit \
     && rm -rf /var/lib/apt/lists/*
 
 # Create a working directory
@@ -40,6 +39,9 @@ else \n\
     echo "NVIDIA driver found. Running nvidia-smi:" \n\
     nvidia-smi \n\
 fi \n\
+echo "Environment variables for GPU:" \n\
+echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}" \n\
+echo "NVIDIA_VISIBLE_DEVICES=${NVIDIA_VISIBLE_DEVICES}" \n\
 exec "$@"' > /entrypoint.sh && \
 chmod +x /entrypoint.sh
 
@@ -48,14 +50,16 @@ COPY requirements.txt .
 
 # Upgrade pip and install dependencies in specific order to avoid conflicts
 RUN pip3 install --no-cache-dir --upgrade pip && \
-    # Install torch and torchvision first
-    pip3 install --no-cache-dir torch==2.0.1 torchvision==0.15.2 && \
+    # Install torch and torchvision first with CUDA support
+    pip3 install --no-cache-dir torch==2.0.1+cu118 torchvision==0.15.2+cu118 --extra-index-url https://download.pytorch.org/whl/cu118 && \
     # Install core dependencies
     pip3 install --no-cache-dir numpy==1.24.3 scipy==1.11.3 requests==2.31.0 && \
     # Install typing-extensions first to ensure proper version for other packages
     pip3 install --no-cache-dir typing-extensions==4.10.0 && \
     # Install huggingface dependencies
     pip3 install --no-cache-dir transformers==4.37.2 safetensors==0.4.1 huggingface_hub==0.19.4 && \
+    # Install timm for vision models
+    pip3 install --no-cache-dir timm==0.9.11 && \
     # Install lmdeploy and its dependencies first
     pip3 install --no-cache-dir "accelerate==0.30.0" && \
     pip3 install --no-cache-dir "lmdeploy==0.5.3" && \

Dockerfile.gpu_test

@@ -0,0 +1,40 @@
+FROM huggingface/transformers-pytorch-gpu:latest
+
+# Set basic environment variables
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Install Python requirements
+RUN pip install --no-cache-dir gradio==3.38.0 pillow numpy
+
+# Copy diagnostic script
+COPY gpu_test.py /app/
+
+# Add a script to check GPU status at startup
+RUN echo '#!/bin/bash \n\
+echo "==== GPU DIAGNOSTICS STARTUP CHECKS ====" \n\
+echo "Checking NVIDIA driver and CUDA:" \n\
+nvidia-smi || echo "nvidia-smi failed - GPU may not be properly configured" \n\
+echo "Current GPU-related environment variables:" \n\
+echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}" \n\
+echo "NVIDIA_VISIBLE_DEVICES=${NVIDIA_VISIBLE_DEVICES}" \n\
+echo "==== STARTING APPLICATION ====" \n\
+exec "$@"' > /entrypoint.sh && \
+chmod +x /entrypoint.sh
+
+# Make port 7860 available for the app
+EXPOSE 7860
+
+# Use our entrypoint script to check GPU status before starting the app
+ENTRYPOINT ["/entrypoint.sh"]
+
+# Start the application
+CMD ["python", "gpu_test.py"] 

Dockerfile.simple

@@ -0,0 +1,24 @@
+FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Install Python requirements
+RUN pip install --no-cache-dir transformers==4.37.2 gradio==3.38.0 pillow
+
+# Copy application files
+COPY simple_gpu_app.py /app/app.py
+
+# Make port 7860 available for the app
+EXPOSE 7860
+
+# Start the application
+CMD ["python", "app.py"] 

app_internvl2.py

@@ -6,10 +6,45 @@ import numpy as np
 import torch
 import warnings
 import stat
+import subprocess
+import sys
 
 # Set environment variables
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"
 
+# Print system information
+print(f"Python version: {sys.version}")
+print(f"PyTorch version: {torch.__version__}")
+print(f"CUDA available via PyTorch: {torch.cuda.is_available()}")
+print(f"CUDA version via PyTorch: {torch.version.cuda if torch.cuda.is_available() else 'Not available'}")
+
+# Try to run nvidia-smi
+def run_nvidia_smi():
+    try:
+        result = subprocess.run(['nvidia-smi'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        if result.returncode == 0:
+            print("nvidia-smi output:")
+            print(result.stdout)
+            return True
+        else:
+            print("nvidia-smi error:")
+            print(result.stderr)
+            return False
+    except Exception as e:
+        print(f"Error running nvidia-smi: {str(e)}")
+        return False
+
+# Run nvidia-smi
+nvidia_smi_available = run_nvidia_smi()
+print(f"nvidia-smi available: {nvidia_smi_available}")
+
+# Show CUDA devices
+if torch.cuda.is_available():
+    print(f"CUDA device count: {torch.cuda.device_count()}")
+    for i in range(torch.cuda.device_count()):
+        print(f"CUDA Device {i}: {torch.cuda.get_device_name(i)}")
+    print(f"Current CUDA device: {torch.cuda.current_device()}")
+
 # Ensure all cache directories exist with proper permissions
 def setup_cache_directories():
     # Gradio cache directory
@@ -44,14 +79,18 @@ warnings.filterwarnings("ignore", category=UserWarning)
 # Check for actual GPU availability
 def check_gpu_availability():
     """Check if GPU is actually available and working"""
+    print("Checking GPU availability...")
+    
     if not torch.cuda.is_available():
         print("CUDA is not available in PyTorch")
         return False
     
     try:
         # Try to initialize CUDA and run a simple operation
+        print("Attempting to create a tensor on CUDA...")
         x = torch.rand(10, device="cuda")
         y = x + x
+        print("Successfully created and operated on CUDA tensor")
         return True
     except Exception as e:
         print(f"GPU initialization failed: {str(e)}")
@@ -72,9 +111,9 @@ try:
     from lmdeploy import pipeline, TurbomindEngineConfig
     LMDEPLOY_AVAILABLE = True
     print("Successfully imported lmdeploy")
-except ImportError:
+except ImportError as e:
     LMDEPLOY_AVAILABLE = False
-    print("lmdeploy import failed. Will use a placeholder for demos.")
+    print(f"lmdeploy import failed: {str(e)}. Will use a placeholder for demos.")
 
 # Model configuration
 MODEL_ID = "OpenGVLab/InternVL2-40B-AWQ"  # 4-bit quantized model
@@ -137,7 +176,7 @@ def analyze_image(image, prompt):
         if not USE_GPU:
             return ("ERROR: This application requires a GPU to run InternVL2. "
                   "The NVIDIA driver was not detected on this system. "
-                  "Please make sure this Space is using a GPU-enabled instance.")
+                  "Please make sure this Space is using a GPU-enabled instance and that the GPU is correctly initialized.")
         
         # Make sure the model is loaded
         if not load_internvl2_model():
@@ -197,6 +236,17 @@ def process_image(image, analysis_type="general"):
 def create_interface():
     with gr.Blocks(title="Image Analysis with InternVL2") as demo:
         gr.Markdown("# Image Analysis with InternVL2-40B")
+        
+        # System diagnostics
+        system_info = f"""
+        ## System Diagnostics:
+        - PyTorch Version: {torch.__version__}
+        - CUDA Available: {torch.cuda.is_available()}
+        - GPU Working: {USE_GPU}
+        - nvidia-smi Available: {nvidia_smi_available}
+        """
+        
+        gr.Markdown(system_info)
         gr.Markdown("Upload an image to analyze it using the InternVL2-40B model.")
         
         # Show warnings based on system status
@@ -223,7 +273,15 @@ def create_interface():
             with gr.Column(scale=2):
                 output_text = gr.Textbox(label="Analysis Result", lines=20)
                 if not USE_GPU:
-                    output_text.value = "ERROR: NVIDIA GPU driver not detected. This application requires GPU acceleration to run the InternVL2 model. Please ensure this Space is using a GPU-enabled instance."
+                    output_text.value = f"""ERROR: NVIDIA GPU driver not detected. This application requires GPU acceleration to run the InternVL2 model.
+
+Diagnostics:
+- PyTorch Version: {torch.__version__}
+- CUDA Available via PyTorch: {torch.cuda.is_available()}
+- nvidia-smi Available: {nvidia_smi_available}
+- GPU Working: {USE_GPU}
+
+Please ensure this Space is using a GPU-enabled instance and that the GPU is correctly initialized."""
         
         submit_btn.click(
             fn=process_image,

gpu_test.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+GPU Diagnostics Tool for Hugging Face Spaces
+This script performs a comprehensive check of GPU availability and functionality.
+"""
+
+import os
+import sys
+import subprocess
+import time
+import json
+
+print("=" * 80)
+print("GPU DIAGNOSTICS TOOL")
+print("=" * 80)
+
+# Check Python version
+print(f"Python version: {sys.version}")
+print("-" * 80)
+
+# Check environment variables
+print("ENVIRONMENT VARIABLES:")
+gpu_related_vars = [
+    "CUDA_VISIBLE_DEVICES",
+    "NVIDIA_VISIBLE_DEVICES",
+    "PYTORCH_CUDA_ALLOC_CONF",
+    "HF_HOME"
+]
+
+for var in gpu_related_vars:
+    print(f"{var}: {os.environ.get(var, 'Not set')}")
+print("-" * 80)
+
+# Check for nvidia-smi
+print("CHECKING FOR NVIDIA-SMI:")
+try:
+    result = subprocess.run(['nvidia-smi'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    if result.returncode == 0:
+        print("nvidia-smi is available and working!")
+        print(result.stdout)
+    else:
+        print("nvidia-smi error:")
+        print(result.stderr)
+except Exception as e:
+    print(f"Error running nvidia-smi: {str(e)}")
+print("-" * 80)
+
+# Check PyTorch and CUDA
+print("CHECKING PYTORCH AND CUDA:")
+try:
+    import torch
+
+    print(f"PyTorch version: {torch.__version__}")
+    print(f"CUDA available: {torch.cuda.is_available()}")
+    print(f"CUDA version: {torch.version.cuda if torch.cuda.is_available() else 'Not available'}")
+    
+    if torch.cuda.is_available():
+        print(f"CUDA device count: {torch.cuda.device_count()}")
+        for i in range(torch.cuda.device_count()):
+            print(f"CUDA Device {i}: {torch.cuda.get_device_name(i)}")
+        print(f"Current CUDA device: {torch.cuda.current_device()}")
+    
+    # Try to create and operate on a CUDA tensor
+    print("\nTesting CUDA tensor creation:")
+    try:
+        start_time = time.time()
+        x = torch.rand(1000, 1000, device="cuda" if torch.cuda.is_available() else "cpu")
+        y = x @ x  # Matrix multiplication to test computation
+        torch.cuda.synchronize()  # Wait for the operation to complete
+        end_time = time.time()
+        
+        if torch.cuda.is_available():
+            print(f"Successfully created and operated on a CUDA tensor in {end_time - start_time:.4f} seconds")
+        else:
+            print(f"Created and operated on a CPU tensor in {end_time - start_time:.4f} seconds (CUDA not available)")
+    except Exception as e:
+        print(f"Error in tensor creation/operation: {str(e)}")
+    
+    # Try to get more detailed CUDA info
+    if torch.cuda.is_available():
+        print("\nDetailed CUDA information:")
+        print(f"CUDA capability: {torch.cuda.get_device_capability(0)}")
+        print(f"Total GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+        print(f"CUDA arch list: {torch.cuda.get_arch_list() if hasattr(torch.cuda, 'get_arch_list') else 'Not available'}")
+except ImportError:
+    print("PyTorch is not installed")
+print("-" * 80)
+
+# Create a simple GPU test with a web interface
+print("CREATING SIMPLE GPU TEST WEB INTERFACE...")
+try:
+    import gradio as gr
+
+    def check_gpu():
+        results = {
+            "python_version": sys.version,
+            "environment_vars": {var: os.environ.get(var, "Not set") for var in gpu_related_vars},
+            "torch_available": False,
+            "cuda_available": False
+        }
+        
+        try:
+            import torch
+            results["torch_available"] = True
+            results["torch_version"] = torch.__version__
+            results["cuda_available"] = torch.cuda.is_available()
+            
+            if torch.cuda.is_available():
+                results["cuda_version"] = torch.version.cuda
+                results["cuda_device_count"] = torch.cuda.device_count()
+                results["cuda_device_name"] = torch.cuda.get_device_name(0)
+                
+                # Test tensor creation
+                start_time = time.time()
+                x = torch.rand(1000, 1000, device="cuda")
+                y = x @ x
+                torch.cuda.synchronize()
+                end_time = time.time()
+                results["tensor_test_time"] = f"{end_time - start_time:.4f} seconds"
+                results["gpu_test_passed"] = True
+            else:
+                results["gpu_test_passed"] = False
+        except Exception as e:
+            results["error"] = str(e)
+            results["gpu_test_passed"] = False
+            
+        return json.dumps(results, indent=2)
+
+    demo = gr.Interface(
+        fn=check_gpu,
+        inputs=[],
+        outputs="text",
+        title="GPU Diagnostics",
+        description="Click the button to run GPU diagnostics"
+    )
+    
+    print("Starting Gradio web interface on port 7860...")
+    demo.launch(server_name="0.0.0.0")
+except ImportError:
+    print("Gradio not installed, skipping web interface")
+    print("Raw GPU diagnostics complete.")
+print("-" * 80) 

requirements.txt

@@ -15,4 +15,5 @@ huggingface_hub==0.19.4
 packaging==23.2
 pyyaml==6.0.1
 tqdm==4.66.1
-typing-extensions==4.10.0 
+typing-extensions==4.10.0
+timm==0.9.11 

simple_gpu_app.py

@@ -0,0 +1,96 @@
+import gradio as gr
+import torch
+from transformers import AutoProcessor, AutoModelForVision2Seq
+from PIL import Image
+
+# Print system information
+print(f"PyTorch version: {torch.__version__}")
+print(f"CUDA available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"CUDA device: {torch.cuda.get_device_name(0)}")
+
+# Load a smaller model that should work even with limited resources
+model_id = "Salesforce/blip-image-captioning-base"  # ~1 GB model, very reliable
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {device}")
+
+# Create global variables for model and processor
+processor = None
+model = None
+
+def load_model():
+    global processor, model
+    try:
+        print("Loading model and processor...")
+        processor = AutoProcessor.from_pretrained(model_id)
+        model = AutoModelForVision2Seq.from_pretrained(model_id).to(device)
+        print("Model loaded successfully")
+        return True
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        return False
+
+def analyze_image(image):
+    # If model not loaded yet, try to load it
+    global processor, model
+    if model is None:
+        success = load_model()
+        if not success:
+            return "Failed to load model. Check logs for details."
+    
+    try:
+        if isinstance(image, str):
+            # If image is a filepath
+            image = Image.open(image).convert('RGB')
+        elif not isinstance(image, Image.Image):
+            # If image is numpy array (from gradio)
+            image = Image.fromarray(image).convert('RGB')
+            
+        # Process image
+        inputs = processor(images=image, return_tensors="pt").to(device)
+        
+        # Generate caption
+        with torch.no_grad():
+            output = model.generate(**inputs, max_length=100)
+        
+        # Decode caption
+        caption = processor.decode(output[0], skip_special_tokens=True)
+        
+        # Get device information
+        if device == "cuda":
+            memory_info = torch.cuda.memory_allocated() / 1024**2
+            return f"Caption: {caption}\n\nUsing device: {device} ({torch.cuda.get_device_name(0)})\nGPU memory used: {memory_info:.2f} MB"
+        else:
+            return f"Caption: {caption}\n\nUsing device: {device}"
+            
+    except Exception as e:
+        print(f"Error during inference: {e}")
+        return f"Error during inference: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="Simple GPU Test") as demo:
+    gr.Markdown("# Simple GPU Test with BLIP Image Captioning")
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(type="pil", label="Upload an image")
+            submit_btn = gr.Button("Generate Caption")
+            
+            # Show if GPU is available
+            if torch.cuda.is_available():
+                gr.Markdown(f"✅ **GPU detected**: {torch.cuda.get_device_name(0)}")
+            else:
+                gr.Markdown("❌ **No GPU detected**. Running on CPU.")
+                
+        with gr.Column():
+            output_text = gr.Textbox(label="Result", lines=5)
+    
+    submit_btn.click(
+        fn=analyze_image,
+        inputs=[image_input],
+        outputs=[output_text]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0") 

upload_gpu_test.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Script to upload GPU diagnostics to Hugging Face Spaces
+"""
+
+import os
+import sys
+import getpass
+from huggingface_hub import HfApi, create_repo, upload_file
+
+# Default repository name
+DEFAULT_REPO = "mknolan/gpu-diagnostic-test"
+
+def main():
+    """Main function to upload files to Hugging Face Spaces"""
+    # Get Hugging Face token with WRITE access
+    token = getpass.getpass("Enter your Hugging Face token (with WRITE access): ")
+    
+    # Get repository name
+    repo_name = input("Enter repository name (default: {}): ".format(DEFAULT_REPO)) or DEFAULT_REPO
+    
+    print("Uploading to Space: {}".format(repo_name))
+    
+    # Initialize Hugging Face API
+    api = HfApi(token=token)
+    
+    try:
+        # Try to get the repository, create if it doesn't exist
+        try:
+            repo = api.repo_info(repo_id=repo_name, repo_type="space")
+            print("Repo {} ready".format(repo_name))
+        except Exception:
+            print("Creating new Space: {}".format(repo_name))
+            create_repo(
+                repo_id=repo_name,
+                token=token,
+                repo_type="space",
+                space_sdk="gradio",
+                private=False
+            )
+        
+        # Upload each file separately for more control
+        files_to_upload = [
+            "gpu_test.py",
+            "Dockerfile.gpu_test"
+        ]
+        
+        print("Uploading diagnostic files to Hugging Face Space...")
+        
+        # Upload Dockerfile as "Dockerfile" (HF requires this name)
+        api.upload_file(
+            path_or_fileobj="Dockerfile.gpu_test",
+            path_in_repo="Dockerfile",
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add Docker configuration for GPU diagnostics"
+        )
+        print("Uploaded Dockerfile")
+        
+        # Upload the Python script
+        api.upload_file(
+            path_or_fileobj="gpu_test.py",
+            path_in_repo="app.py",  # HF Spaces often looks for app.py as the main file
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add GPU diagnostic script"
+        )
+        print("Uploaded gpu_test.py as app.py")
+        
+        # Create a README.md file
+        readme_content = """# GPU Diagnostics Tool
+
+This Space provides diagnostics for GPU detection and functionality in Hugging Face Spaces.
+
+## Purpose
+- Tests if CUDA is available through PyTorch
+- Tests if nvidia-smi can detect the GPU
+- Tests tensor operations on GPU
+- Provides detailed diagnostic information about the GPU environment
+
+## How to Use
+1. Click the "Submit" button
+2. View the JSON results to diagnose GPU issues
+"""
+        
+        # Write README to a temporary file
+        with open("temp_readme.md", "w") as f:
+            f.write(readme_content)
+        
+        # Upload README
+        api.upload_file(
+            path_or_fileobj="temp_readme.md",
+            path_in_repo="README.md",
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add README"
+        )
+        print("Uploaded README.md")
+        
+        # Clean up temp file
+        os.remove("temp_readme.md")
+        
+        print("Upload completed!")
+        print("Check your Space at: https://huggingface.co/spaces/{}".format(repo_name))
+        
+    except Exception as e:
+        print("Error: {}".format(e))
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main()) 

upload_gpu_test_direct.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Script to upload GPU diagnostics to Hugging Face Spaces with direct token input
+"""
+
+import os
+import sys
+from huggingface_hub import HfApi, create_repo, upload_file
+
+# Default repository name
+DEFAULT_REPO = "mknolan/gpu-diagnostic-test"
+# Token should be entered at runtime, not hardcoded
+DEFAULT_TOKEN = ""
+
+def main():
+    """Main function to upload files to Hugging Face Spaces"""
+    # Get Hugging Face token with WRITE access - direct input instead of getpass
+    if DEFAULT_TOKEN:
+        token = DEFAULT_TOKEN
+    else:
+        token = input("Enter your Hugging Face token (with WRITE access): ")
+    
+    # Get repository name
+    repo_name = input("Enter repository name (default: {}): ".format(DEFAULT_REPO)) or DEFAULT_REPO
+    
+    print("Uploading to Space: {}".format(repo_name))
+    
+    # Initialize Hugging Face API
+    api = HfApi(token=token)
+    
+    try:
+        # Try to get the repository, create if it doesn't exist
+        try:
+            repo = api.repo_info(repo_id=repo_name, repo_type="space")
+            print("Repo {} ready".format(repo_name))
+        except Exception:
+            print("Creating new Space: {}".format(repo_name))
+            create_repo(
+                repo_id=repo_name,
+                token=token,
+                repo_type="space",
+                space_sdk="gradio",
+                private=False
+            )
+        
+        print("Uploading diagnostic files to Hugging Face Space...")
+        
+        # Upload Dockerfile as "Dockerfile" (HF requires this name)
+        api.upload_file(
+            path_or_fileobj="Dockerfile.gpu_test",
+            path_in_repo="Dockerfile",
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add Docker configuration for GPU diagnostics"
+        )
+        print("Uploaded Dockerfile")
+        
+        # Upload the Python script
+        api.upload_file(
+            path_or_fileobj="gpu_test.py",
+            path_in_repo="app.py",  # HF Spaces often looks for app.py as the main file
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add GPU diagnostic script"
+        )
+        print("Uploaded gpu_test.py as app.py")
+        
+        # Create a README.md file
+        readme_content = """# GPU Diagnostics Tool
+
+This Space provides diagnostics for GPU detection and functionality in Hugging Face Spaces.
+
+## Purpose
+- Tests if CUDA is available through PyTorch
+- Tests if nvidia-smi can detect the GPU
+- Tests tensor operations on GPU
+- Provides detailed diagnostic information about the GPU environment
+
+## How to Use
+1. Click the "Submit" button
+2. View the JSON results to diagnose GPU issues
+"""
+        
+        # Write README to a temporary file
+        with open("temp_readme.md", "w") as f:
+            f.write(readme_content)
+        
+        # Upload README
+        api.upload_file(
+            path_or_fileobj="temp_readme.md",
+            path_in_repo="README.md",
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add README"
+        )
+        print("Uploaded README.md")
+        
+        # Clean up temp file
+        os.remove("temp_readme.md")
+        
+        print("Upload completed!")
+        print("Check your Space at: https://huggingface.co/spaces/{}".format(repo_name))
+        
+    except Exception as e:
+        print("Error: {}".format(e))
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main()) 

upload_simple_app.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Script to upload a simple BLIP model to test GPU functionality on Hugging Face Spaces
+"""
+
+import os
+import sys
+from huggingface_hub import HfApi, create_repo, upload_file
+
+# Default repository name
+DEFAULT_REPO = "mknolan/simple-gpu-test"
+# Token should be provided at runtime
+DEFAULT_TOKEN = ""
+
+def main():
+    """Main function to upload files to Hugging Face Spaces"""
+    # Get Hugging Face token
+    token = DEFAULT_TOKEN if DEFAULT_TOKEN else input("Enter your Hugging Face token (with WRITE access): ")
+    
+    # Get repository name
+    repo_name = input("Enter repository name (default: {}): ".format(DEFAULT_REPO)) or DEFAULT_REPO
+    
+    print("Uploading to Space: {}".format(repo_name))
+    
+    # Initialize Hugging Face API
+    api = HfApi(token=token)
+    
+    try:
+        # Try to get the repository, create if it doesn't exist
+        try:
+            repo = api.repo_info(repo_id=repo_name, repo_type="space")
+            print("Repo {} ready".format(repo_name))
+        except Exception:
+            print("Creating new Space: {}".format(repo_name))
+            create_repo(
+                repo_id=repo_name,
+                token=token,
+                repo_type="space",
+                space_sdk="docker",
+                private=False
+            )
+        
+        print("Uploading files to Hugging Face Space...")
+        
+        # Upload Dockerfile
+        api.upload_file(
+            path_or_fileobj="Dockerfile.simple",
+            path_in_repo="Dockerfile",
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add Docker configuration for simple GPU test"
+        )
+        print("Uploaded Dockerfile")
+        
+        # Upload the Python script
+        api.upload_file(
+            path_or_fileobj="simple_gpu_app.py",
+            path_in_repo="app.py",
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add simple GPU test application"
+        )
+        print("Uploaded simple_gpu_app.py as app.py")
+        
+        # Create a README.md file
+        readme_content = """# Simple GPU Test with BLIP
+
+This Space provides a simple test of GPU functionality using the BLIP image captioning model.
+
+## Features
+- Uses a lightweight model (~1GB) that runs efficiently even on limited GPU resources
+- Provides GPU detection and memory usage information
+- Simple interface for testing if GPU is working
+
+## How to Use
+1. Upload an image
+2. Click "Generate Caption"
+3. View the results, including GPU usage information
+"""
+        
+        # Write README to a temporary file
+        with open("temp_readme.md", "w") as f:
+            f.write(readme_content)
+        
+        # Upload README
+        api.upload_file(
+            path_or_fileobj="temp_readme.md",
+            path_in_repo="README.md",
+            repo_id=repo_name,
+            repo_type="space",
+            token=token,
+            commit_message="Add README"
+        )
+        print("Uploaded README.md")
+        
+        # Clean up temp file
+        os.remove("temp_readme.md")
+        
+        print("Upload completed!")
+        print("Check your Space at: https://huggingface.co/spaces/{}".format(repo_name))
+        
+    except Exception as e:
+        print("Error: {}".format(e))
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())