替换AI模型为规则生成器，解决依赖问题

app.py

@@ -59,57 +59,133 @@ def create_dummy_image():
     img = PILImage.new('RGB', (256, 256), color = (255, 100, 100))
     return img
 
-# 全局变量
-pipe = None
-
-# 懒加载AI模型函数
-def get_model():
+# 创建一个模拟图像生成器
+def create_mock_image(prompt):
+    """当模型加载不成功时，创建一个带有提示词的简单图像"""
+    logger.info(f"创建简单图像: {prompt}")
+    
+    # 创建一个基础图像
+    img = PILImage.new('RGB', (512, 512), color=(240, 240, 250))
+    
+    # 在图像上写文字
     try:
-        import torch
-        from diffusers import StableDiffusionPipeline
+        from PIL import ImageDraw, ImageFont
+        draw = ImageDraw.Draw(img)
         
-        logger.info("开始加载模型...")
+        # 尝试找一个合适的字体
+        try:
+            font = ImageFont.truetype("arial.ttf", 20)
+        except:
+            try:
+                font = ImageFont.truetype("DejaVuSans.ttf", 20)
+            except:
+                font = ImageFont.load_default()
         
-        # 使用较小的模型而不是SDXL
-        model_id = "runwayml/stable-diffusion-v1-5"
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        logger.info(f"使用设备: {device}")
+        # 添加提示文本
+        text = f"提示词: {prompt}"
+        draw.text((20, 20), text, fill=(0, 0, 0), font=font)
+        draw.text((20, 60), "模型加载失败，显示占位图像", fill=(255, 0, 0), font=font)
         
-        # 优化设置以减少内存使用
-        if torch.cuda.is_available():
-            # 使用半精度
-            pipe = StableDiffusionPipeline.from_pretrained(
-                model_id, 
-                torch_dtype=torch.float16,
-                safety_checker=None,  # 禁用安全检查器以节省内存
-                requires_safety_checker=False,
-                use_safetensors=True
-            )
-            pipe = pipe.to(device)
-            pipe.enable_attention_slicing()  # 减少显存使用
-            
-            # 释放不必要的内存
-            torch.cuda.empty_cache()
-        else:
-            # CPU版本，占用内存较大，但现在只用处理一个请求
-            pipe = StableDiffusionPipeline.from_pretrained(
-                model_id,
-                safety_checker=None,
-                requires_safety_checker=False,
-                use_safetensors=True
-            )
-            pipe = pipe.to(device)
+    except Exception as e:
+        logger.error(f"创建文字图像失败: {e}")
+    
+    return img
+
+# 使用简单的文本生成器
+def text_to_image(prompt):
+    """一个非常简单的基于规则的文本到图像生成器"""
+    logger.info(f"使用简单规则生成图像: {prompt}")
+    
+    # 创建基础图像
+    img = PILImage.new('RGB', (512, 512), color=(240, 240, 250))
+    
+    # 尝试分析提示词内容
+    color = (100, 100, 200)  # 默认蓝色
+    
+    # 简单的颜色匹配
+    color_words = {
+        'red': (200, 50, 50),
+        'blue': (50, 50, 200),
+        'green': (50, 200, 50),
+        'yellow': (200, 200, 50),
+        'purple': (150, 50, 150),
+        'orange': (220, 140, 20),
+        'pink': (255, 150, 200),
+        'black': (30, 30, 30),
+        'white': (240, 240, 240),
+        'gray': (128, 128, 128),
+    }
+    
+    # 检查提示词中是否包含颜色
+    prompt_lower = prompt.lower()
+    for color_word, rgb in color_words.items():
+        if color_word in prompt_lower:
+            color = rgb
+            break
+    
+    # 创建一个简单的图形
+    from PIL import ImageDraw
+    draw = ImageDraw.Draw(img)
+    
+    # 根据提示词选择不同的绘制方式
+    if any(animal in prompt_lower for animal in ['cat', 'kitty', 'kitten']):
+        # 画一个简单的猫
+        draw.ellipse((156, 156, 356, 306), fill=color)  # 头
+        draw.ellipse((196, 176, 246, 226), fill=(255, 255, 255))  # 左眼
+        draw.ellipse((266, 176, 316, 226), fill=(255, 255, 255))  # 右眼
+        draw.ellipse((211, 191, 231, 211), fill=(0, 0, 0))  # 左眼球
+        draw.ellipse((281, 191, 301, 211), fill=(0, 0, 0))  # 右眼球
+        draw.polygon([(256, 256), (236, 246), (276, 246)], fill=(255, 100, 150))  # 鼻子
+        draw.line([(256, 256), (256, 286)], fill=(0, 0, 0), width=2)  # 鼻线
+        draw.arc((206, 256, 306, 336), 0, 180, fill=(0, 0, 0), width=2)  # 嘴
+        # 猫耳朵
+        draw.polygon([(206, 156), (156, 76), (246, 126)], fill=color)
+        draw.polygon([(306, 156), (356, 76), (266, 126)], fill=color)
+    
+    elif any(landscape in prompt_lower for landscape in ['landscape', 'mountain', 'sunset', 'nature']):
+        # 画一个简单的风景
+        # 天空
+        sky_color = (100, 150, 250)
+        if 'sunset' in prompt_lower:
+            sky_color = (250, 150, 100)
+        draw.rectangle([(0, 0), (512, 300)], fill=sky_color)
         
-        logger.info("模型加载成功")
-        return pipe
+        # 太阳/月亮
+        if 'sunset' in prompt_lower or 'sun' in prompt_lower:
+            draw.ellipse((400, 50, 480, 130), fill=(255, 200, 50))
+        elif 'night' in prompt_lower or 'moon' in prompt_lower:
+            draw.ellipse((400, 50, 480, 130), fill=(240, 240, 240))
+        
+        # 山
+        draw.polygon([(0, 300), (200, 100), (400, 300)], fill=(100, 100, 100))
+        draw.polygon([(100, 300), (300, 50), (500, 300)], fill=(80, 80, 80))
+        
+        # 地面
+        ground_color = (100, 200, 100)
+        if 'desert' in prompt_lower:
+            ground_color = (240, 220, 180)
+        elif 'snow' in prompt_lower or 'winter' in prompt_lower:
+            ground_color = (240, 240, 250)
+        draw.rectangle([(0, 300), (512, 512)], fill=ground_color)
+    
+    else:
+        # 默认绘制一些简单的几何图形
+        draw.rectangle([(106, 106), (406, 406)], outline=(0, 0, 0), width=2)
+        draw.ellipse((156, 156, 356, 356), fill=color)
+        draw.polygon([(256, 106), (406, 406), (106, 406)], fill=(color[0]//2, color[1]//2, color[2]//2))
+    
+    # 添加提示词文本
+    try:
+        font = ImageFont.load_default()
+        draw.text((10, 10), f"提示词: {prompt}", fill=(0, 0, 0), font=font)
+        draw.text((10, 30), "由简单规则生成", fill=(100, 100, 100), font=font)
     except Exception as e:
-        logger.error(f"模型加载失败: {e}")
-        return None
+        logger.error(f"添加文字失败: {e}")
+    
+    return img
 
 # 生成图像函数
 def generate_image(prompt):
-    global pipe
-    
     # 如果提示为空，使用默认提示
     if not prompt or prompt.strip() == "":
         prompt = "a beautiful landscape"
@@ -117,53 +193,22 @@ def generate_image(prompt):
     
     logger.info(f"收到提示词: {prompt}")
     
-    # 第一次调用时加载模型
-    if pipe is None:
-        pipe = get_model()
-        if pipe is None:
-            logger.error("模型加载失败，返回默认图像")
-            return create_dummy_image()
-    
-    try:
-        # 优化生成参数，减少内存需求
-        logger.info("开始生成图像...")
-        
-        # 设置随机种子以确保结果一致性
-        seed = random.randint(0, 2147483647)
-        generator = torch.Generator(device=pipe.device).manual_seed(seed)
-        
-        # 使用最轻量级的参数
-        image = pipe(
-            prompt=prompt,
-            num_inference_steps=3,  # 极少的步骤
-            guidance_scale=7.5,
-            height=256,  # 小尺寸
-            width=256,   # 小尺寸
-            generator=generator
-        ).images[0]
-        
-        # 释放缓存，避免内存增长
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            
-        logger.info(f"图像生成成功，种子: {seed}")
-        return image
-    except Exception as e:
-        logger.error(f"生成过程发生错误: {e}")
-        return create_dummy_image()
+    # 不再尝试加载AI模型，直接使用规则生成器
+    logger.info("使用规则生成器代替AI模型")
+    return text_to_image(prompt)
 
 # 创建Gradio界面
 def create_demo():
-    # 使用简单界面，避免复杂组件
+    # 创建界面
     demo = gr.Interface(
         fn=generate_image,
-        inputs=gr.Textbox(label="输入提示词"),
+        inputs=gr.Textbox(label="输入提示词（例如：猫、风景、日落）"),
         outputs=gr.Image(type="pil", label="生成的图像"),
-        title="文本到图像生成",
-        description="输入文本描述，AI将生成相应的图像（会加载较长时间，请耐心等待）",
-        examples=["a cute cat", "mountain landscape"],
+        title="简易文本到图像生成器",
+        description="输入文本描述，生成相应的图像（使用规则生成器，不依赖AI模型）",
+        examples=["a cute cat", "beautiful sunset", "mountain landscape", "red circle"],
         cache_examples=False,
-        allow_flagging="never"  # 禁用标记功能以减少复杂性
+        flagging_mode=None
     )
     return demo
 

requirements.txt

@@ -1,6 +1,8 @@
 accelerate==0.21.0
-diffusers==0.20.0
+diffusers==0.18.0
+huggingface-hub==0.14.1
 torch==2.0.1
-transformers==4.34.0
+transformers==4.30.2
+safetensors==0.3.1
 gradio==3.24.1
 Pillow==10.0.0