Switch to API-based image generation for better compatibility with Hugging Face Spaces

app.py

@@ -4,6 +4,10 @@ import random
 import logging
 import sys
 import os
+import requests
+import io
+import json
+import base64
 from PIL import Image as PILImage
 
 # 设置日志记录
@@ -75,74 +79,112 @@ def create_backup_image(prompt=""):
 # 预加载图像用于快速响应
 PLACEHOLDER_IMAGE = create_backup_image("placeholder")
 
-# 尝试导入必要的AI库
-try:
-    import torch
-    from diffusers import StableDiffusionPipeline
-
-    HAS_AI_LIBS = True
-    logger.info("Successfully imported AI libraries")
-except ImportError as e:
-    logger.error(f"Failed to import AI libraries: {e}")
-    HAS_AI_LIBS = False
-
-# AI 模型加载和图像生成
-def generate_ai_image(prompt, seed=None):
-    if not HAS_AI_LIBS:
-        logger.error("AI libraries not available")
-        return PLACEHOLDER_IMAGE
+# 使用 Hugging Face Inference API 生成图像
+def generate_image_with_api(prompt, api_url=None, api_key=None):
+    """
+    使用 Hugging Face Inference API 生成图像
+    
+    Parameters:
+    - prompt: 文本提示
+    - api_url: API 端点 URL (可选)
+    - api_key: API 密钥 (可选)
+    
+    Returns:
+    - PIL Image
+    """
+    logger.info(f"Generating image via API for: {prompt}")
+    
+    # 默认使用 Stable Diffusion API
+    if api_url is None:
+        api_url = "https://api-inference.huggingface.co/models/runwayml/stable-diffusion-v1-5"
     
-    # 设置随机种子
-    if seed is None:
-        seed = random.randint(0, 2147483647)
+    # 尝试从环境变量中获取 API 密钥
+    if api_key is None:
+        api_key = os.environ.get("HF_API_KEY", "")
+    
+    # 如果没有 API 密钥，使用公共访问（可能会受到速率限制）
+    headers = {}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
     
     try:
-        logger.info(f"Generating image for: {prompt}")
-        
-        # 使用兼容的旧版本API加载模型
-        model_id = "runwayml/stable-diffusion-v1-5"
-        logger.info(f"Loading model: {model_id}")
-        
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+        # 设置请求参数
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "num_inference_steps": 10,  # 减少推理步骤以加快速度
+                "guidance_scale": 7.5,
+                "width": 512,
+                "height": 512
+            }
+        }
         
-        # 加载模型 - 使用兼容的低级API
-        pipe = StableDiffusionPipeline.from_pretrained(
-            model_id,
-            torch_dtype=torch_dtype,
-            use_auth_token=False,  # 明确不使用认证
-            safety_checker=None,   # 禁用安全检查器
-        )
-        pipe = pipe.to(device)
-        
-        # 优化内存
-        if torch.cuda.is_available():
-            pipe.enable_attention_slicing()
-            torch.cuda.empty_cache()
+        # 发送请求
+        response = requests.post(api_url, headers=headers, json=payload)
         
-        logger.info("Model loaded, generating image...")
+        # 检查响应是否成功
+        if response.status_code == 200:
+            # 从响应中获取图像
+            image = PILImage.open(io.BytesIO(response.content))
+            logger.info("Successfully generated image via API")
+            return image
+        else:
+            # 如果遇到错误，记录响应并返回备用图像
+            error_text = response.text
+            logger.error(f"API error: {response.status_code}, {error_text}")
+            return None
         
-        # 生成图像
-        generator = torch.Generator(device).manual_seed(seed)
-        image = pipe(
-            prompt=prompt,
-            guidance_scale=7.5,
-            num_inference_steps=4,  # 最小步数
-            generator=generator,
-            height=512,
-            width=512
-        ).images[0]
+    except Exception as e:
+        logger.error(f"Failed to generate image via API: {e}")
+        return None
+
+# 使用 Hugging Face Spaces 内置模型生成图像
+def generate_image_with_spaces(prompt):
+    """使用同一个 Hugging Face Space 内的其他公共空间来生成图像"""
+    logger.info(f"Generating image via Spaces for: {prompt}")
+    
+    try:
+        # 一些公共可用的 Stable Diffusion 空间 URLs
+        space_urls = [
+            "https://huggingface-projects-stable-diffusion-demo.hf.space/api/predict",
+            "https://huggingface-projects-text-to-image.hf.space/api/predict",
+            "https://dataautogpt-playground.hf.space/api/predict"
+        ]
         
-        # 清理缓存
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            
-        logger.info(f"Image generation successful with seed: {seed}")
-        return image
+        # 尝试每个 URL 直到成功
+        for url in space_urls:
+            try:
+                payload = {
+                    "data": [prompt, 7.5, 512, 512] 
+                }
+                response = requests.post(url, json=payload, timeout=30)
+                
+                if response.status_code == 200:
+                    # 解析 JSON 响应
+                    result = response.json()
+                    
+                    # 根据结果格式提取图像数据
+                    if isinstance(result, dict) and 'data' in result:
+                        image_data = result['data'][0]
+                        
+                        # 检查图像数据格式
+                        if image_data.startswith('data:image'):
+                            # 提取 base64 图像数据
+                            image_b64 = image_data.split(',')[1]
+                            image_bytes = base64.b64decode(image_b64)
+                            image = PILImage.open(io.BytesIO(image_bytes))
+                            logger.info(f"Successfully generated image via {url}")
+                            return image
+            except Exception as e:
+                logger.warning(f"Failed to generate with {url}: {e}")
+                continue
         
+        logger.error("All space URLs failed")
+        return None
+    
     except Exception as e:
-        logger.error(f"AI image generation failed: {e}")
-        return create_backup_image(prompt)
+        logger.error(f"Failed to generate image via Spaces: {e}")
+        return None
 
 # 使用简单的规则生成图像作为备用方案
 def generate_rule_based_image(prompt):
@@ -235,17 +277,19 @@ def generate_image(prompt):
     
     logger.info(f"Received prompt: {prompt}")
     
-    # 尝试使用AI生成
-    if HAS_AI_LIBS:
-        try:
-            image = generate_ai_image(prompt)
-            if image is not None:
-                return image
-        except Exception as e:
-            logger.error(f"Error using AI generation: {e}")
+    # 尝试使用 Hugging Face API 生成
+    image = generate_image_with_api(prompt)
+    if image is not None:
+        return image
+    
+    # 如果 API 方法失败，尝试使用 Spaces
+    logger.info("API method failed, trying Spaces method...")
+    image = generate_image_with_spaces(prompt)
+    if image is not None:
+        return image
     
-    # 如果AI不可用或失败，使用规则生成
-    logger.warning("Using rule-based image generation")
+    # 如果所有 AI 方法都失败，使用规则生成
+    logger.warning("All AI methods failed, using rule-based image generation")
     return generate_rule_based_image(prompt)
 
 # 为旧版 gradio 创建界面
@@ -260,7 +304,7 @@ def create_demo():
         ),
         outputs=gr.Image(label="Generated Image", type="pil"),
         title="Text to Image Generator",
-        description="Enter a text description to generate an image.",
+        description="Enter a text description to generate an image. This demo uses Hugging Face API for image generation.",
         examples=[
             "a cute cat sitting on a windowsill",
             "beautiful sunset over mountains",

requirements.txt

@@ -1,8 +1,3 @@
-accelerate>=0.15.0
-diffusers==0.10.2
-huggingface-hub>=0.13.0
-torch==1.13.1
-transformers>=4.25.1
-safetensors>=0.3.1
-gradio>=3.19.1,<3.25.0
-Pillow>=9.0.0,<10.0.0
+requests>=2.26.0
+Pillow>=9.0.0,<10.0.0
+gradio>=3.19.1,<3.25.0