1

app.py

@@ -1,320 +1,356 @@
-import subprocess
-import sys
 import os
-import gradio as gr
+import sys
+import warnings
+warnings.filterwarnings("ignore")
 
-def install_package(package):
-    """安装Python包"""
-    try:
-        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
-        return True
-    except subprocess.CalledProcessError:
-        return False
+# 基础导入检查
+try:
+    import gradio as gr
+    from PIL import Image
+    import torch
+    print(f"✅ PyTorch 版本: {torch.__version__}")
+    
+    # 检查PyTorch版本
+    torch_version = torch.__version__
+    major, minor = map(int, torch_version.split('.')[:2])
+    if major < 2 or (major == 2 and minor < 6):
+        print(f"⚠️ PyTorch 版本 {torch_version} 可能存在安全问题")
+    
+except ImportError as e:
+    print(f"❌ 基础库导入失败: {e}")
+    with gr.Blocks() as error_demo:
+        gr.HTML("<h2>❌ 基础环境错误</h2>")
+    error_demo.launch()
+    sys.exit(1)
 
-def check_and_install_dependencies():
-    """检查并安装依赖"""
-    print("🔍 检查依赖库...")
+# 尝试导入transformers
+try:
+    from transformers import AutoTokenizer, AutoModel, AutoProcessor, Blip2ForConditionalGeneration
+    print("✅ Transformers 导入成功")
+except ImportError as e:
+    print(f"❌ Transformers 导入失败: {e}")
+    with gr.Blocks() as error_demo:
+        gr.HTML(f"<h2>❌ Transformers 未安装</h2><p>{str(e)}</p>")
+    error_demo.launch()
+    sys.exit(1)
+
+# HF Spaces 环境检测
+IS_SPACES = os.environ.get("SPACE_ID") is not None
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"环境: {'HF Spaces' if IS_SPACES else 'Local'}, 设备: {device}")
+
+# 全局变量
+tokenizer = None
+model = None
+processor = None
+blip_model = None
+
+def load_models():
+    """加载模型 - 改进版本"""
+    global tokenizer, model, processor, blip_model
     
-    # 检查transformers
     try:
-        import transformers
-        print("✅ transformers 已安装")
-        return True
-    except ImportError:
-        print("❌ transformers 未安装，尝试安装...")
+        print("🔄 开始加载模型...")
+        
+        # 1. 首先加载图像模型（通常更稳定）
+        vision_model = "Salesforce/blip2-opt-2.7b"
+        print(f"📷 加载图像模型: {vision_model}")
+        
+        processor = AutoProcessor.from_pretrained(vision_model)
+        blip_model = Blip2ForConditionalGeneration.from_pretrained(
+            vision_model,
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+            device_map="auto" if device == "cuda" else None,
+            load_in_8bit=device == "cuda",
+            trust_remote_code=True
+        )
+        
+        if device == "cpu":
+            blip_model = blip_model.to("cpu")
         
-        # 尝试安装transformers
-        packages_to_install = [
-            "transformers==4.35.2",
-            "accelerate==0.24.1",
-            "bitsandbytes==0.41.3"
-        ]
+        print("✅ 图像模型加载完成")
         
-        for package in packages_to_install:
-            print(f"📦 安装 {package}...")
-            if install_package(package):
-                print(f"✅ {package} 安装成功")
-            else:
-                print(f"❌ {package} 安装失败")
+        # 2. 加载对话模型 - 使用更兼容的配置
+        model_name = "THUDM/chatglm2-6b-int4"
+        print(f"💬 加载对话模型: {model_name}")
         
-        # 再次检查
         try:
-            import transformers
-            print("✅ transformers 现已可用")
+            tokenizer = AutoTokenizer.from_pretrained(
+                model_name,
+                trust_remote_code=True,
+                use_fast=False  # 使用慢速tokenizer可能更稳定
+            )
+            
+            model = AutoModel.from_pretrained(
+                model_name,
+                trust_remote_code=True,
+                torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+                low_cpu_mem_usage=True,
+                device_map="auto" if device == "cuda" else None
+            )
+            
+            if device == "cuda":
+                model = model.half().cuda()
+            model.eval()
+            
+            print("✅ 对话模型加载完成")
             return True
-        except ImportError:
-            print("❌ transformers 安装后仍不可用")
-            return False
-
-# 检查并安装依赖
-dependencies_ok = check_and_install_dependencies()
-
-if dependencies_ok:
-    # 如果依赖OK，导入所需库
-    try:
-        import torch
-        from transformers import AutoTokenizer, AutoModel, AutoProcessor, Blip2ForConditionalGeneration
-        from PIL import Image
-        print("✅ 所有库导入成功")
-        
-        # 在这里放置你的完整应用代码
-        # HF Spaces 环境检测
-        IS_SPACES = os.environ.get("SPACE_ID") is not None
-        print(f"Running on HF Spaces: {IS_SPACES}")
-
-        # 设备配置
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"Using device: {device}")
-
-        # 全局变量
-        tokenizer = None
-        model = None
-        processor = None
-        blip_model = None
-
-        def load_models():
-            """加载模型"""
-            global tokenizer, model, processor, blip_model
             
+        except Exception as chat_error:
+            print(f"⚠️ ChatGLM加载失败: {str(chat_error)}")
+            print("🔄 尝试使用备用对话模型...")
+            
+            # 备用方案：使用更简单的对话模型
             try:
-                print("🔄 正在加载模型...")
-                
-                # 加载图像理解模型
-                vision_model = "Salesforce/blip2-opt-2.7b"
-                print(f"📷 加载图像模型: {vision_model}")
-                processor = AutoProcessor.from_pretrained(vision_model)
-                
-                blip_model = Blip2ForConditionalGeneration.from_pretrained(
-                    vision_model,
-                    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
-                    device_map="auto" if device == "cuda" else None,
-                    load_in_8bit=device == "cuda"
-                )
-                
-                if device == "cpu":
-                    blip_model = blip_model.to("cpu")
-                    
-                print("✅ 图像模型加载完成")
-                
-                # 加载对话模型
-                model_name = "THUDM/chatglm2-6b-int4"
-                print(f"💬 加载对话模型: {model_name}")
-                
-                tokenizer = AutoTokenizer.from_pretrained(
-                    model_name, 
-                    trust_remote_code=True
-                )
-                
-                model = AutoModel.from_pretrained(
-                    model_name,
-                    trust_remote_code=True,
-                    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
-                    low_cpu_mem_usage=True
-                )
+                backup_model = "microsoft/DialoGPT-medium"
+                tokenizer = AutoTokenizer.from_pretrained(backup_model)
+                model = AutoModel.from_pretrained(backup_model)
                 
                 if device == "cuda":
-                    model = model.half().cuda()
+                    model = model.cuda()
                 model.eval()
                 
-                print("✅ 对话模型加载完成")
+                print("✅ 备用对话模型加载完成")
                 return True
                 
-            except Exception as e:
-                print(f"❌ 模型加载失败: {str(e)}")
-                return False
-
-        def describe_image(image):
-            """生成图像描述"""
-            if blip_model is None or processor is None:
-                return "图像模型未加载"
-            
-            try:
-                if not isinstance(image, Image.Image):
-                    image = Image.fromarray(image)
-                
-                if image.size[0] > 512 or image.size[1] > 512:
-                    image.thumbnail((512, 512), Image.Resampling.LANCZOS)
-                
-                inputs = processor(image, return_tensors="pt")
-                
-                if device == "cuda":
-                    inputs = {k: v.to(device) for k, v in inputs.items()}
-                
-                with torch.no_grad():
-                    generated_ids = blip_model.generate(
-                        **inputs,
-                        max_new_tokens=30,
-                        num_beams=2,
-                        do_sample=False
-                    )
-                
-                caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
-                return caption
-                
-            except Exception as e:
-                print(f"图像描述错误: {str(e)}")
-                return f"图像描述生成失败"
+            except Exception as backup_error:
+                print(f"❌ 备用模型也加载失败: {str(backup_error)}")
+                # 至少图像模型可用
+                return "partial"
+        
+    except Exception as e:
+        print(f"❌ 模型加载完全失败: {str(e)}")
+        return False
 
-        def on_image_upload(image):
-            """处理图像上传"""
-            if image is None:
-                return [], []
-            
-            try:
-                print("🖼️ 处理上传的图像...")
-                history = []
-                chat_history = []
-                
-                caption = describe_image(image)
-                print(f"图像描述: {caption}")
-                
-                prompt = f"这是一幅艺术作品，描述为: {caption}。请用中文对这件艺术作品进行介绍和分析。"
-                
-                if model is not None and tokenizer is not None:
-                    try:
-                        with torch.no_grad():
-                            response, history = model.chat(tokenizer, prompt, history=history)
-                        chat_history.append([image, response])
-                        print("✅ 初始分析完成")
-                    except Exception as e:
-                        print(f"对话生成错误: {str(e)}")
-                        chat_history.append([image, f"很抱歉，分析过程中出现了错误。请重新尝试。"])
-                else:
-                    chat_history.append([image, "对话模型未正确加载，请刷新页面重试。"])
-                
-                return chat_history, history
-                
-            except Exception as e:
-                print(f"图像处理错误: {str(e)}")
-                return [[None, "图像处理失败，请重新上传。"]], []
+def describe_image(image):
+    """图像描述功能"""
+    if blip_model is None or processor is None:
+        return "图像模型未加载"
+    
+    try:
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+        
+        # 调整图像大小
+        if image.size[0] > 512 or image.size[1] > 512:
+            image.thumbnail((512, 512), Image.Resampling.LANCZOS)
+        
+        inputs = processor(image, return_tensors="pt")
+        
+        if device == "cuda":
+            inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        with torch.no_grad():
+            generated_ids = blip_model.generate(
+                **inputs,
+                max_new_tokens=50,
+                num_beams=3,
+                do_sample=True,
+                temperature=0.7
+            )
+        
+        caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
+        return caption
+        
+    except Exception as e:
+        print(f"图像描述错误: {str(e)}")
+        return "图像描述生成失败"
 
-        def on_user_message(user_message, chat_history, history):
-            """处理用户消息"""
-            if not user_message or not user_message.strip():
-                yield chat_history or [], history or []
-                return
-            
-            if model is None or tokenizer is None:
-                chat_history = chat_history or []
-                chat_history.append([user_message, "对话模型未加载，请刷新页面。"])
-                yield chat_history, history or []
-                return
-            
-            try:
-                chat_history = chat_history or []
-                history = history or []
-                chat_history.append([user_message, ""])
-                
-                for output, new_history in model.stream_chat(
-                    tokenizer, 
-                    user_message, 
-                    history,
-                    max_length=2048,
-                    temperature=0.7,
-                    top_p=0.8
-                ):
-                    chat_history[-1][1] = output
-                    yield chat_history, new_history
-                    
-            except Exception as e:
-                print(f"对话错误: {str(e)}")
-                if chat_history:
-                    chat_history[-1][1] = "回复生成失败，请重试。"
-                yield chat_history, history or []
+def generate_analysis(caption):
+    """生成艺术品分析"""
+    if model is None or tokenizer is None:
+        # 如果没有对话模型，使用预设的分析模板
+        return f"""
+基于图像内容: {caption}
 
-        def clear_chat():
-            """清空对话"""
-            return [], []
+这幅艺术作品展现了独特的视觉表现力。从构图角度来看，作品体现了艺术家对空间布局的精心安排。
+色彩运用方面，展现了艺术家的色彩敏感度和表现技巧。
+整体而言，这是一件具有艺术价值的作品，值得进一步欣赏和研究。
 
-        # 创建界面
-        with gr.Blocks(title="AI艺术品讲解智能体") as demo:
-            gr.HTML("""
-            <div style="text-align: center; margin-bottom: 20px;">
-                <h1>🎨 AI 艺术品讲解智能体</h1>
-                <p>上传艺术品图像，获得专业的艺术分析和解读</p>
-            </div>
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    image_input = gr.Image(
-                        label="📤 上传艺术品图像",
-                        type="pil",
-                        height=350
-                    )
-                    clear_btn = gr.Button("🗑️ 清空对话", variant="secondary")
-                    
-                with gr.Column(scale=2):
-                    chatbot = gr.Chatbot(
-                        label="🤖 AI 分析师",
-                        height=500,
-                        show_label=True
-                    )
-                    
-            user_input = gr.Textbox(
-                label="💬 继续提问",
-                placeholder="例如：这幅作品使用了什么绘画技法？创作背景如何？",
-                lines=2
-            )
-            
-            # 状态管理
-            state = gr.State([])
-            
-            # 事件绑定
-            image_input.upload(
-                fn=on_image_upload,
-                inputs=image_input,
-                outputs=[chatbot, state],
-                show_progress=True
-            )
+注：当前使用简化分析模式，如需详细分析请等待对话模型加载完成。
+        """.strip()
+    
+    try:
+        prompt = f"这是一幅艺术作品，描述为: {caption}。请用中文对这件艺术作品进行详细的介绍和分析。"
+        
+        # 检查模型类型
+        if hasattr(model, 'chat'):
+            # ChatGLM模型
+            response, _ = model.chat(tokenizer, prompt, history=[])
+        else:
+            # 其他模型的通用方法
+            inputs = tokenizer.encode(prompt, return_tensors="pt")
+            if device == "cuda":
+                inputs = inputs.cuda()
             
-            user_input.submit(
-                fn=on_user_message,
-                inputs=[user_input, chatbot, state],
-                outputs=[chatbot, state],
-                show_progress=True
-            )
+            with torch.no_grad():
+                outputs = model.generate(
+                    inputs,
+                    max_length=inputs.shape[1] + 200,
+                    num_return_sequences=1,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=tokenizer.eos_token_id
+                )
             
-            user_input.submit(lambda: "", inputs=[], outputs=[user_input])
-            clear_btn.click(fn=clear_chat, inputs=[], outputs=[chatbot, state])
+            response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
+        
+        return response
+        
+    except Exception as e:
+        print(f"分析生成错误: {str(e)}")
+        return f"基于图像内容 '{caption}' 的分析生成遇到问题，请重试。"
+
+def on_image_upload(image):
+    """处理图像上传"""
+    if image is None:
+        return [], []
+    
+    try:
+        print("🖼️ 处理图像...")
+        history = []
+        chat_history = []
+        
+        # 生成图像描述
+        caption = describe_image(image)
+        print(f"图像描述: {caption}")
+        
+        # 生成分析
+        analysis = generate_analysis(caption)
+        chat_history.append([image, analysis])
+        
+        return chat_history, history
+        
+    except Exception as e:
+        print(f"图像处理错误: {str(e)}")
+        return [[None, "图像处理失败，请重新上传。"]], []
 
-        # 启动应用
-        print("🚀 启动应用...")
-        if load_models():
-            print("✅ 启动成功")
-            demo.queue(max_size=20).launch()
+def on_user_message(user_message, chat_history, history):
+    """处理用户消息"""
+    if not user_message or not user_message.strip():
+        yield chat_history or [], history or []
+        return
+    
+    chat_history = chat_history or []
+    history = history or []
+    
+    if model is None or tokenizer is None:
+        chat_history.append([user_message, "对话功能暂时不可用，仅支持图像分析。"])
+        yield chat_history, history
+        return
+    
+    try:
+        chat_history.append([user_message, ""])
+        
+        # 检查模型类型并生成回复
+        if hasattr(model, 'stream_chat'):
+            # ChatGLM流式回复
+            for output, new_history in model.stream_chat(tokenizer, user_message, history):
+                chat_history[-1][1] = output
+                yield chat_history, new_history
         else:
-            print("❌ 模型加载失败，启动简化版本")
-            with gr.Blocks() as simple_demo:
-                gr.HTML("<h2>模型加载失败</h2><p>请等待依赖安装完成后重试</p>")
-            simple_demo.launch()
+            # 其他模型的简单回复
+            response = generate_analysis(user_message)  # 复用分析功能
+            chat_history[-1][1] = response
+            yield chat_history, history
             
     except Exception as e:
-        print(f"❌ 导入失败: {str(e)}")
-        # 创建错误页面
-        with gr.Blocks() as error_demo:
-            gr.HTML(f"""
-            <div style="text-align: center; padding: 50px;">
-                <h2>❌ 库导入失败</h2>
-                <p>错误: {str(e)}</p>
-                <p>正在尝试自动修复...</p>
-            </div>
-            """)
-        error_demo.launch()
+        print(f"对话错误: {str(e)}")
+        chat_history[-1][1] = "对话生成失败，请重试。"
+        yield chat_history, history
 
-else:
-    # 依赖安装失败，显示错误页面
-    with gr.Blocks() as error_demo:
+def clear_chat():
+    return [], []
+
+# 创建界面
+def create_interface():
+    with gr.Blocks(
+        title="AI艺术品讲解智能体",
+        theme=gr.themes.Soft()
+    ) as demo:
         gr.HTML("""
-        <div style="text-align: center; padding: 50px;">
-            <h2>❌ 依赖安装失败</h2>
-            <p>transformers 库无法安装</p>
-            <p>请尝试以下解决方案：</p>
-            <ol style="text-align: left; display: inline-block;">
-                <li>检查 requirements.txt 文件是否存在</li>
-                <li>在 Settings 中执行 Factory reboot</li>
-                <li>等待 HF Spaces 重新构建环境</li>
-            </ol>
+        <div style="text-align: center; margin-bottom: 20px;">
+            <h1>🎨 AI 艺术品讲解智能体</h1>
+            <p>上传艺术品图像，获得专业的艺术分析</p>
         </div>
         """)
-    error_demo.launch()
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                image_input = gr.Image(
+                    label="📤 上传艺术品图像",
+                    type="pil",
+                    height=350
+                )
+                clear_btn = gr.Button("🗑️ 清空对话", variant="secondary")
+                
+                # 模型状态显示
+                status_display = gr.HTML(
+                    "<div style='padding:10px; background:#f0f0f0; border-radius:5px;'>"
+                    "<b>模型状态:</b> 正在加载..."
+                    "</div>"
+                )
+                
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(
+                    label="🤖 AI 分析师",
+                    height=500
+                )
+                
+        user_input = gr.Textbox(
+            label="💬 继续提问",
+            placeholder="请输入关于艺术作品的问题...",
+            lines=2
+        )
+        
+        state = gr.State([])
+        
+        # 事件绑定
+        image_input.upload(
+            fn=on_image_upload,
+            inputs=image_input,
+            outputs=[chatbot, state]
+        )
+        
+        user_input.submit(
+            fn=on_user_message,
+            inputs=[user_input, chatbot, state],
+            outputs=[chatbot, state]
+        )
+        
+        user_input.submit(lambda: "", inputs=[], outputs=[user_input])
+        clear_btn.click(fn=clear_chat, inputs=[], outputs=[chatbot, state])
+    
+    return demo, status_display
+
+# 主程序
+if __name__ == "__main__":
+    print("🚀 启动 AI 艺术品讲解智能体...")
+    
+    demo, status_display = create_interface()
+    
+    # 加载模型
+    model_status = load_models()
+    
+    if model_status == True:
+        status_msg = "✅ 所有模型加载完成"
+        print(status_msg)
+    elif model_status == "partial":
+        status_msg = "⚠️ 图像模型可用，对话功能受限"
+        print(status_msg)
+    else:
+        status_msg = "❌ 模型加载失败"
+        print(status_msg)
+    
+    # 更新状态显示
+    try:
+        demo.launch(
+            share=False,
+            show_error=True,
+            quiet=False
+        )
+    except Exception as e:
+        print(f"启动失败: {str(e)}")
+        with gr.Blocks() as error_demo:
+            gr.HTML(f"<h2>启动失败</h2><p>{str(e)}</p>")
+        error_demo.launch()