Create app.py

app.py

@@ -0,0 +1,723 @@
+# app.py - 完整的单文件时尚AI应用
+# 无需复杂的模块导入，直接在 Hugging Face Spaces 运行
+
+import gradio as gr
+import torch
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import logging
+import time
+import random
+import os
+from datetime import datetime
+from typing import Dict, List, Optional
+
+# 设置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# 尝试导入AI模型库
+try:
+    from transformers import (
+        BlipProcessor, BlipForConditionalGeneration,
+        CLIPProcessor, CLIPModel,
+        pipeline
+    )
+    from diffusers import (
+        StableDiffusionPipeline, 
+        ControlNetModel, 
+        StableDiffusionControlNetPipeline
+    )
+    from sklearn.cluster import KMeans
+    import cv2
+    MODELS_AVAILABLE = True
+    logger.info("✅ 所有AI库导入成功")
+except ImportError as e:
+    logger.warning(f"⚠️ 部分AI库未安装: {e}")
+    MODELS_AVAILABLE = False
+
+# 尝试导入 Hugging Face Spaces GPU 支持
+try:
+    import spaces
+    SPACES_GPU_AVAILABLE = True
+    logger.info("✅ Hugging Face Spaces GPU 支持可用")
+except ImportError:
+    SPACES_GPU_AVAILABLE = False
+    logger.info("ℹ️ 运行在非Spaces环境或无GPU支持")
+
+class FashionAnalyzer:
+    """时尚分析引擎"""
+    
+    def __init__(self):
+        self.style_keywords = {
+            "商务正装": ["suit", "formal", "business", "office", "professional", "blazer", "西装", "正装"],
+            "休闲风格": ["casual", "relaxed", "comfortable", "jeans", "t-shirt", "休闲", "日常"],
+            "运动风格": ["sport", "athletic", "gym", "fitness", "training", "运动", "健身"],
+            "时尚潮流": ["fashion", "trendy", "stylish", "modern", "chic", "时尚", "潮流"],
+            "复古风格": ["vintage", "retro", "classic", "traditional", "复古", "经典"],
+            "街头风格": ["street", "urban", "hip-hop", "edgy", "街头", "嘻哈"],
+            "优雅风格": ["elegant", "sophisticated", "graceful", "classy", "优雅", "高贵"],
+            "极简风格": ["minimalist", "clean", "simple", "basic", "极简", "简约"]
+        }
+        
+        self.color_names = {
+            "红色系": ["红色", "玫瑰红", "深红", "暗红", "鲜红"],
+            "蓝色系": ["蓝色", "天蓝", "海军蓝", "宝石蓝", "钴蓝"],
+            "绿色系": ["绿色", "翠绿", "森林绿", "橄榄绿", "苹果绿"],
+            "黑白灰": ["黑色", "白色", "灰色", "象牙白", "珍珠白", "炭黑"],
+            "暖色调": ["橙色", "黄色", "粉色", "金黄", "柠檬黄"],
+            "冷色调": ["紫色", "青色", "薄荷绿", "紫罗兰", "青绿"]
+        }
+    
+    def extract_colors(self, image: Image.Image, n_colors: int = 5) -> List[Dict]:
+        """提取图像主要颜色"""
+        try:
+            # 调整图像大小以提高处理速度
+            image_small = image.resize((100, 100))
+            img_array = np.array(image_small)
+            pixels = img_array.reshape(-1, 3)
+            
+            # 过滤极端值
+            mask = np.all(pixels > 20, axis=1) & np.all(pixels < 235, axis=1)
+            filtered_pixels = pixels[mask]
+            
+            if len(filtered_pixels) < 50:
+                filtered_pixels = pixels
+            
+            # 使用 K-means 聚类
+            if MODELS_AVAILABLE:
+                kmeans = KMeans(n_clusters=min(n_colors, len(filtered_pixels)), 
+                              random_state=42, n_init=10)
+                kmeans.fit(filtered_pixels)
+                colors = kmeans.cluster_centers_
+                labels = kmeans.labels_
+            else:
+                # 简化版本：直接采样
+                colors = []
+                step = max(1, len(filtered_pixels) // n_colors)
+                for i in range(0, len(filtered_pixels), step):
+                    if len(colors) < n_colors:
+                        colors.append(filtered_pixels[i])
+                colors = np.array(colors)
+                labels = np.zeros(len(colors))
+            
+            color_info = []
+            for i, color in enumerate(colors):
+                rgb = color.astype(int)
+                color_name = self.rgb_to_color_name(rgb)
+                hex_color = '#{:02x}{:02x}{:02x}'.format(*rgb)
+                
+                if MODELS_AVAILABLE:
+                    percentage = np.sum(labels == i) / len(labels) * 100
+                else:
+                    percentage = 100.0 / len(colors)
+                
+                color_info.append({
+                    "name": color_name,
+                    "rgb": rgb.tolist(),
+                    "hex": hex_color,
+                    "percentage": round(percentage, 1)
+                })
+            
+            return sorted(color_info, key=lambda x: x["percentage"], reverse=True)
+            
+        except Exception as e:
+            logger.error(f"颜色提取失败: {e}")
+            return [{"name": "未知颜色", "rgb": [128, 128, 128], "hex": "#808080", "percentage": 100.0}]
+    
+    def rgb_to_color_name(self, rgb: np.ndarray) -> str:
+        """RGB转颜色名称"""
+        r, g, b = rgb
+        
+        if r > 200 and g > 200 and b > 200:
+            return "象牙白" if min(r, g, b) > 240 else "珍珠白"
+        elif r < 50 and g < 50 and b < 50:
+            return "墨黑" if max(r, g, b) < 30 else "炭黑"
+        elif r > max(g, b) + 30:
+            return "玫瑰红" if r > 180 else "深红"
+        elif g > max(r, b) + 30:
+            return "翠绿" if g > 180 else "森林绿"
+        elif b > max(r, g) + 30:
+            return "天蓝" if b > 180 else "海军蓝"
+        elif r > 150 and g > 150 and b < 100:
+            return "金黄" if r > 200 else "暖黄"
+        elif r > 120 and g < 100 and b > 120:
+            return "紫罗兰" if r > 150 else "深紫"
+        else:
+            return "混合色"
+    
+    def analyze_style(self, description: str) -> Dict[str, float]:
+        """分析时尚风格"""
+        description_lower = description.lower()
+        style_scores = {}
+        
+        for style, keywords in self.style_keywords.items():
+            score = sum(1 for keyword in keywords if keyword in description_lower)
+            if score > 0:
+                confidence = min(score / len(keywords) * 100, 100)
+                style_scores[style] = round(confidence, 1)
+        
+        # 如果没有匹配到任何风格，给一个默认分析
+        if not style_scores:
+            style_scores = {"休闲风格": 60.0, "时尚潮流": 40.0}
+        
+        return dict(sorted(style_scores.items(), key=lambda x: x[1], reverse=True))
+
+class ModelManager:
+    """AI模型管理器"""
+    
+    def __init__(self):
+        self.models_loaded = False
+        self.blip_processor = None
+        self.blip_model = None
+        self.clip_processor = None
+        self.clip_model = None
+        self.sd_pipeline = None
+        self.controlnet_pipeline = None
+        
+        if MODELS_AVAILABLE:
+            self.load_models()
+    
+    def load_models(self):
+        """加载AI模型"""
+        try:
+            logger.info("🔄 开始加载AI模型...")
+            
+            # 1. 尝试加载 BLIP 图像理解模型
+            try:
+                logger.info("加载 BLIP 图像理解模型...")
+                self.blip_processor = BlipProcessor.from_pretrained(
+                    "Salesforce/blip-image-captioning-base"
+                )
+                self.blip_model = BlipForConditionalGeneration.from_pretrained(
+                    "Salesforce/blip-image-captioning-base",
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+                )
+                
+                if torch.cuda.is_available():
+                    self.blip_model = self.blip_model.to("cuda")
+                
+                logger.info("✅ BLIP模型加载成功")
+            except Exception as e:
+                logger.warning(f"BLIP模型加载失败: {e}")
+                # 尝试轻量级替代
+                try:
+                    self.blip_model = pipeline("image-to-text", 
+                                             model="nlpconnect/vit-gpt2-image-captioning")
+                    logger.info("✅ 轻量级图像理解模型加载成功")
+                except Exception as e2:
+                    logger.error(f"所有图像理解模型加载失败: {e2}")
+            
+            # 2. 尝试加载 Stable Diffusion
+            try:
+                logger.info("加载 Stable Diffusion 设计生成模型...")
+                self.sd_pipeline = StableDiffusionPipeline.from_pretrained(
+                    "runwayml/stable-diffusion-v1-5",
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                    safety_checker=None,
+                    requires_safety_checker=False
+                )
+                
+                if torch.cuda.is_available():
+                    self.sd_pipeline = self.sd_pipeline.to("cuda")
+                
+                self.sd_pipeline.enable_attention_slicing()
+                logger.info("✅ Stable Diffusion模型加载成功")
+            except Exception as e:
+                logger.warning(f"Stable Diffusion加载失败: {e}")
+            
+            self.models_loaded = True
+            logger.info("🎉 模型加载完成")
+            
+        except Exception as e:
+            logger.error(f"模型加载过程出错: {e}")
+            self.models_loaded = False
+    
+    def generate_description(self, image: Image.Image) -> str:
+        """生成图像描述"""
+        if not self.models_loaded:
+            return "AI模型未就绪，使用基础分析"
+        
+        try:
+            # 使用 BLIP 模型
+            if self.blip_processor and self.blip_model and hasattr(self.blip_model, 'generate'):
+                inputs = self.blip_processor(image, return_tensors="pt")
+                if torch.cuda.is_available() and next(self.blip_model.parameters()).is_cuda:
+                    inputs = {k: v.to("cuda") for k, v in inputs.items()}
+                
+                with torch.no_grad():
+                    generated_ids = self.blip_model.generate(
+                        **inputs, 
+                        max_length=50, 
+                        num_beams=3,
+                        do_sample=True,
+                        temperature=0.7
+                    )
+                
+                description = self.blip_processor.decode(generated_ids[0], skip_special_tokens=True)
+                return description
+            
+            # 使用 pipeline 模型
+            elif hasattr(self.blip_model, '__call__'):
+                result = self.blip_model(image)
+                if isinstance(result, list) and len(result) > 0:
+                    return result[0].get('generated_text', '时尚服装图像')
+            
+            return "时尚服装分析 - 基础模式"
+            
+        except Exception as e:
+            logger.error(f"描述生成失败: {e}")
+            return f"图像分析完成 - {str(e)[:50]}"
+    
+    def generate_fashion_design(self, prompt: str) -> Optional[Image.Image]:
+        """生成时尚设计"""
+        if not self.sd_pipeline:
+            return self.create_placeholder_image("设计生成功能不可用")
+        
+        try:
+            enhanced_prompt = f"high quality fashion design, {prompt}, professional photography, detailed, 4k"
+            negative_prompt = "blurry, low quality, distorted, text, watermark, deformed, ugly"
+            
+            with torch.autocast("cuda" if torch.cuda.is_available() else "cpu"):
+                result = self.sd_pipeline(
+                    prompt=enhanced_prompt,
+                    negative_prompt=negative_prompt,
+                    num_inference_steps=20,
+                    guidance_scale=7.5,
+                    width=512,
+                    height=512
+                )
+            
+            return result.images[0]
+            
+        except Exception as e:
+            logger.error(f"设计生成失败: {e}")
+            return self.create_placeholder_image(f"生成失败: {str(e)[:30]}")
+    
+    def create_placeholder_image(self, text: str) -> Image.Image:
+        """创建占位图"""
+        img = Image.new('RGB', (512, 512), color=(245, 245, 250))
+        draw = ImageDraw.Draw(img)
+        
+        # 计算文本位置
+        text_lines = text.split('\n')
+        y_start = (512 - len(text_lines) * 30) // 2
+        
+        for i, line in enumerate(text_lines):
+            text_width = len(line) * 8
+            x = (512 - text_width) // 2
+            y = y_start + i * 35
+            draw.text((x, y), line, fill=(100, 100, 100))
+        
+        return img
+    
+    def cleanup_memory(self):
+        """清理内存"""
+        try:
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            
+            import gc
+            gc.collect()
+            
+            return "✅ 内存清理完成"
+        except Exception as e:
+            return f"❌ 内存清理失败: {e}"
+
+# 全局实例
+fashion_analyzer = FashionAnalyzer()
+model_manager = ModelManager()
+
+# 主要功能函数
+def analyze_fashion_image(image: Image.Image) -> Dict:
+    """分析时尚图像"""
+    if image is None:
+        return {"error": "请上传图像"}
+    
+    try:
+        logger.info("开始时尚图像分析...")
+        start_time = time.time()
+        
+        # 1. 生成图像描述
+        description = model_manager.generate_description(image)
+        
+        # 2. 色彩分析
+        colors = fashion_analyzer.extract_colors(image, n_colors=5)
+        
+        # 3. 风格分析
+        styles = fashion_analyzer.analyze_style(description)
+        primary_style = list(styles.keys())[0] if styles else "现代时尚"
+        
+        # 4. 综合分析
+        analysis_time = round(time.time() - start_time, 2)
+        
+        result = {
+            "image_description": description,
+            "color_analysis": colors,
+            "style_analysis": styles,
+            "primary_style": primary_style,
+            "main_colors": [c["name"] for c in colors[:3]],
+            "analysis_time": f"{analysis_time}秒",
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "ai_model_status": "✅ 已连接" if model_manager.models_loaded else "⚠️ 基础模式"
+        }
+        
+        logger.info(f"分析完成，耗时 {analysis_time}秒")
+        return result
+        
+    except Exception as e:
+        logger.error(f"分析失败: {e}")
+        return {"error": f"分析过程出错: {str(e)}"}
+
+def generate_design_suggestions(analysis_result: Dict) -> Dict[str, str]:
+    """生成设计建议"""
+    if "error" in analysis_result:
+        return {"基础建议": "请先完成图像分析"}
+    
+    primary_style = analysis_result.get("primary_style", "现代时尚")
+    main_colors = analysis_result.get("main_colors", ["经典色"])
+    
+    suggestions = {
+        f"优化{primary_style}": f"保持{primary_style}特色，突出{main_colors[0]}主色调",
+        f"色彩增强版": f"基于{primary_style}风格，强化{main_colors[0]}和{main_colors[1] if len(main_colors) > 1 else '经典色'}搭配",
+        f"现代融合": f"将{primary_style}与当代设计元素结合",
+        f"个性定制": f"专属{primary_style}风格的个性化设计",
+        f"场景适配": f"适合多种场合的{primary_style}变化"
+    }
+    
+    return suggestions
+
+def generate_designs(suggestion: str, analysis_result: Dict, progress=gr.Progress()) -> List[Image.Image]:
+    """生成设计方案"""
+    if not suggestion or "error" in analysis_result:
+        return [model_manager.create_placeholder_image("请先选择设计建议")]
+    
+    try:
+        primary_style = analysis_result.get("primary_style", "现代时尚")
+        main_colors = analysis_result.get("main_colors", ["经典色"])
+        
+        designs = []
+        design_prompts = [
+            f"{primary_style} style fashion, {main_colors[0]} color, elegant design",
+            f"modern {primary_style} clothing, {main_colors[0]} and {main_colors[1] if len(main_colors) > 1 else 'neutral'} colors",
+            f"professional {primary_style} outfit, premium materials, {main_colors[0]} accent",
+            f"contemporary {primary_style} fashion, artistic design, {main_colors[0]} theme"
+        ]
+        
+        for i, prompt in enumerate(design_prompts):
+            if progress:
+                progress(i / len(design_prompts), f"生成设计方案 {i+1}/{len(design_prompts)}")
+            
+            design_image = model_manager.generate_fashion_design(prompt)
+            designs.append(design_image)
+        
+        if progress:
+            progress(1.0, "设计生成完成")
+        
+        return designs
+        
+    except Exception as e:
+        logger.error(f"设计生成失败: {e}")
+        return [model_manager.create_placeholder_image(f"生成失败: {str(e)[:30]}")]
+
+def create_3d_fitting(selected_design: str) -> Image.Image:
+    """创建3D试穿效果"""
+    if not selected_design:
+        return model_manager.create_placeholder_image("请先选择设计方案")
+    
+    try:
+        # 创建3D试穿提示
+        fitting_prompt = f"3D virtual fashion model wearing {selected_design}, full body view, professional studio lighting, photorealistic"
+        
+        # 生成3D试穿图像
+        fitting_image = model_manager.generate_fashion_design(fitting_prompt)
+        
+        return fitting_image if fitting_image else model_manager.create_placeholder_image("3D试穿生成完成")
+        
+    except Exception as e:
+        logger.error(f"3D试穿生成失败: {e}")
+        return model_manager.create_placeholder_image("3D试穿生成失败")
+
+# Gradio 界面
+def create_fashion_interface():
+    """创建时尚AI界面"""
+    
+    custom_css = """
+    .gradio-container {
+        max-width: 1200px;
+        margin: 0 auto;
+        font-family: 'Inter', sans-serif;
+    }
+    .header {
+        text-align: center;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 15px;
+        margin-bottom: 20px;
+    }
+    .status-info {
+        background: #f8f9fa;
+        padding: 10px;
+        border-radius: 8px;
+        border-left: 4px solid #28a745;
+        margin: 10px 0;
+    }
+    """
+    
+    with gr.Blocks(title="AI时尚设计师", theme=gr.themes.Soft(), css=custom_css) as demo:
+        
+        # 头部
+        gr.HTML(f"""
+            <div class="header">
+                <h1>🎨 AI时尚设计师</h1>
+                <p>智能图像分析 • 个性化设计建议 • AI生成时尚方案</p>
+                <div class="status-info">
+                    <strong>系统状态:</strong> 
+                    {'🟢 GPU可用' if torch.cuda.is_available() else '🟡 CPU模式'} | 
+                    {'✅ AI模型就绪' if model_manager.models_loaded else '⚠️ 基础模式'} |
+                    {'🚀 Spaces GPU' if SPACES_GPU_AVAILABLE else '💻 标准环境'}
+                </div>
+            </div>
+        """)
+        
+        # 主界面
+        with gr.Row():
+            # 左侧：图像上传和分析
+            with gr.Column(scale=1):
+                gr.Markdown("## 📸 图像分析")
+                
+                image_input = gr.Image(
+                    type="pil", 
+                    label="上传时尚图片",
+                    height=300
+                )
+                
+                analyze_btn = gr.Button(
+                    "🔍 AI智能分析",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                # 分析状态
+                analysis_status = gr.Textbox(
+                    label="分析状态",
+                    value="等待图片上传...",
+                    interactive=False
+                )
+            
+            # 右侧：分析结果
+            with gr.Column(scale=2):
+                gr.Markdown("## 📊 分析结果")
+                
+                with gr.Tabs():
+                    with gr.Tab("🔍 详细分析"):
+                        analysis_output = gr.JSON(label="AI分析报告")
+                    
+                    with gr.Tab("🎨 色彩分析"):
+                        color_gallery = gr.DataFrame(
+                            headers=["颜色名称", "RGB值", "十六进制", "占比%"],
+                            label="色彩详细信息"
+                        )
+        
+        # 设计建议部分
+        gr.Markdown("## 💡 个性化设计建议")
+        
+        with gr.Row():
+            suggestions_radio = gr.Radio(
+                label="选择设计方向",
+                interactive=True
+            )
+            generate_btn = gr.Button(
+                "🚀 生成设计方案",
+                variant="primary"
+            )
+        
+        # 设计结果
+        with gr.Tabs():
+            with gr.Tab("🎯 设计方案"):
+                designs_gallery = gr.Gallery(
+                    label="AI生成的设计方案",
+                    columns=2,
+                    rows=2,
+                    height=400
+                )
+                
+                design_choice = gr.Radio(
+                    label="选择方案进行3D试穿",
+                    interactive=True
+                )
+                
+                fitting_btn = gr.Button(
+                    "👤 生成3D试穿",
+                    variant="primary"
+                )
+            
+            with gr.Tab("👥 3D试穿"):
+                fitting_output = gr.Image(
+                    label="3D虚拟试穿效果",
+                    height=500
+                )
+        
+        # 系统控制
+        with gr.Accordion("⚙️ 系统控制", open=False):
+            with gr.Row():
+                cleanup_btn = gr.Button("🧹 清理内存")
+                memory_status = gr.Textbox(label="内存状态", interactive=False)
+        
+        # 状态存储
+        analysis_state = gr.State({})
+        
+        # 事件处理
+        def process_analysis(image):
+            if image is None:
+                return {}, gr.Radio(choices=[]), [], "❌ 请先上传图片", {}
+            
+            # 执行分析
+            result = analyze_fashion_image(image)
+            
+            if "error" in result:
+                return result, gr.Radio(choices=[]), [], f"❌ {result['error']}", result
+            
+            # 生成建议
+            suggestions = generate_design_suggestions(result)
+            choices = list(suggestions.keys())
+            
+            # 准备色彩数据
+            color_data = []
+            for color in result.get("color_analysis", []):
+                color_data.append([
+                    color["name"],
+                    str(color["rgb"]),
+                    color["hex"],
+                    f"{color['percentage']}%"
+                ])
+            
+            status = f"✅ 分析完成 - 耗时 {result.get('analysis_time', '未知')}"
+            
+            return (
+                result,
+                gr.Radio(choices=choices, value=choices[0] if choices else None),
+                color_data,
+                status,
+                result
+            )
+        
+        analyze_btn.click(
+            fn=process_analysis,
+            inputs=[image_input],
+            outputs=[
+                analysis_output,
+                suggestions_radio,
+                color_gallery,
+                analysis_status,
+                analysis_state
+            ]
+        )
+        
+        # 设计生成
+        def handle_design_generation(suggestion, analysis_result):
+            if not suggestion or "error" in analysis_result:
+                return [], gr.Radio(choices=[])
+            
+            designs = generate_designs(suggestion, analysis_result)
+            choices = [f"{suggestion} - 方案{i+1}" for i in range(len(designs))]
+            
+            return designs, gr.Radio(choices=choices, value=choices[0] if choices else None)
+        
+        generate_btn.click(
+            fn=handle_design_generation,
+            inputs=[suggestions_radio, analysis_state],
+            outputs=[designs_gallery, design_choice]
+        )
+        
+        # 3D试穿
+        fitting_btn.click(
+            fn=create_3d_fitting,
+            inputs=[design_choice],
+            outputs=[fitting_output]
+        )
+        
+        # 内存清理
+        cleanup_btn.click(
+            fn=model_manager.cleanup_memory,
+            inputs=[],
+            outputs=[memory_status]
+        )
+        
+        # 底部信息
+        gr.Markdown("""
+        ---
+        ### 🔧 技术说明
+        
+        **AI技术栈:**
+        - 🔤 BLIP: 专业图像理解与描述生成
+        - 🎨 Stable Diffusion: 高质量时尚设计生成
+        - 🧮 K-means聚类: 智能色彩分析
+        - 📊 风格识别: 多维度时尚风格评估
+        
+        **系统特点:**
+        - ✅ 单文件部署，无模块导入错误
+        - 🚀 自动GPU/CPU适配
+        - 🛡️ 完善的错误处理机制
+        - 📱 响应式用户界面
+        
+        > 💡 **使用提示**: 首次运行会下载AI模型，请耐心等待。生成过程可能需要1-3分钟。
+        """)
+    
+    return demo
+
+# 主函数
+def main():
+    """应用主入口"""
+    try:
+        logger.info("🚀 启动AI时尚设计师应用...")
+        logger.info(f"PyTorch版本: {torch.__version__}")
+        logger.info(f"CUDA可用: {torch.cuda.is_available()}")
+        logger.info(f"AI模型库可用: {MODELS_AVAILABLE}")
+        
+        # 创建界面
+        demo = create_fashion_interface()
+        
+        # 配置启动参数
+        demo.queue(
+            concurrency_count=2 if torch.cuda.is_available() else 1,
+            max_size=10
+        )
+        
+        # 启动应用
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=int(os.environ.get("PORT", 7860)),
+            share=False,
+            show_error=True,
+            debug=False
+        )
+        
+    except Exception as e:
+        logger.error(f"应用启动失败: {e}")
+        print(f"启动错误: {e}")
+        
+        # 创建最小化的错误页面
+        with gr.Blocks() as error_demo:
+            gr.HTML(f"""
+                <div style="text-align: center; padding: 50px;">
+                    <h1>❌ 应用启动失败</h1>
+                    <p><strong>错误信息:</strong> {str(e)}</p>
+                    <p><strong>PyTorch可用:</strong> {torch.__version__ if 'torch' in globals() else '未安装'}</p>
+                    <p><strong>CUDA可用:</strong> {torch.cuda.is_available() if 'torch' in globals() else '未知'}</p>
+                    <hr>
+                    <h2>🛠️ 故障排除建议:</h2>
+                    <ol style="text-align: left; max-width: 600px; margin: 0 auto;">
+                        <li>检查 requirements.txt 中的依赖是否正确安装</li>
+                        <li>确认 Hugging Face Spaces 环境配置</li>
+                        <li>检查 GPU 资源是否可用</li>
+                        <li>查看完整的错误日志</li>
+                    </ol>
+                </div>
+            """)
+        
+        error_demo.launch()
+
+if __name__ == "__main__":
+    main()