Upload folder using huggingface_hub

app.py

@@ -81,26 +81,56 @@ class ModelHandler:
             print(f"❌ Model loading failed: {e}")
             raise e
 
-    def predict(self, messages, temperature, max_tokens):
-        # 这里的 messages 已经是处理好的标准 OpenAI 格式列表
+    def predict(self, message_dict, history, temperature, max_tokens):
+        text = message_dict.get("text", "")
+        files = message_dict.get("files", [])
+
+        messages = []
         
-        # 将 sys_prompt 注入到最后一条用户消息中
-        if messages and messages[-1]["role"] == "user":
-            content = messages[-1]["content"]
-            sys_prompt_fmt = "\n" + " ".join(sys_prompt.split())
-            
-            if isinstance(content, str):
-                messages[-1]["content"] += sys_prompt_fmt
-            elif isinstance(content, list):
-                # 查找文本部分并追加，如果没有则添加
-                text_found = False
-                for item in content:
-                    if item.get("type") == "text":
-                        item["text"] += sys_prompt_fmt
-                        text_found = True
-                        break
-                if not text_found:
-                    content.append({"type": "text", "text": sys_prompt_fmt})
+        if history:
+            print(f"Processing {len(history)} previous messages from history")
+            for msg in history:
+                role = msg.get("role", "")
+                content = msg.get("content", "")
+                
+                if role == "user":
+                    user_content = []
+                    
+                    if isinstance(content, list):
+                        for item in content:
+                            if isinstance(item, str):
+                                if os.path.exists(item) or any(item.lower().endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']):
+                                    user_content.append({"type": "image", "image": item})
+                                else:
+                                    user_content.append({"type": "text", "text": item})
+                            elif isinstance(item, dict):
+                                user_content.append(item)
+                    elif isinstance(content, str):
+                        if content:
+                            user_content.append({"type": "text", "text": content})
+                    
+                    if user_content:
+                        messages.append({"role": "user", "content": user_content})
+                        
+                elif role == "assistant":
+                    if isinstance(content, str) and content:
+                        messages.append({"role": "assistant", "content": content})
+        
+        current_content = []
+        if files:
+            for file_path in files:
+                current_content.append({"type": "image", "image": file_path})
+        
+        if text:
+            sys_prompt_formatted = " ".join(sys_prompt.split())
+            full_text = f"{text}\n{sys_prompt_formatted}"
+            current_content.append({"type": "text", "text": full_text})
+        
+        if current_content:
+            messages.append({"role": "user", "content": current_content})
+        
+        print(f"Total messages for model: {len(messages)}")
+        print(f"Message roles: {[m['role'] for m in messages]}")
 
         text_prompt = self.processor.apply_chat_template(
             messages, tokenize=False, add_generation_prompt=True
@@ -125,17 +155,37 @@ class ModelHandler:
             do_sample=True if temperature > 0 else False,
         )
 
-        with torch.no_grad():
-            generated_ids = self.model.generate(**generation_kwargs)
-        
-        input_length = inputs['input_ids'].shape[1]
-        generated_ids = generated_ids[0][input_length:]
-        
-        generated_text = self.processor.tokenizer.decode(
-            generated_ids, skip_special_tokens=True
-        )
-        
-        yield generated_text
+        try:
+            print("Starting model generation...")
+            with torch.no_grad():
+                generated_ids = self.model.generate(**generation_kwargs)
+            
+            input_length = inputs['input_ids'].shape[1]
+            generated_ids = generated_ids[0][input_length:]
+            
+            print(f"Input length: {input_length}, Generated token count: {len(generated_ids)}")
+            
+            generated_text = self.processor.tokenizer.decode(
+                generated_ids, 
+                skip_special_tokens=True
+            )
+            
+            print(f"Generation completed. Output length: {len(generated_text)}, Content preview: {repr(generated_text[:200])}")
+            
+            if generated_text and generated_text.strip():
+                print(f"Yielding generated text: {generated_text[:100]}...")
+                yield generated_text
+            else:
+                warning_msg = "⚠️ No output generated. The model may not have produced any response."
+                print(warning_msg)
+                yield warning_msg
+                
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            print(f"Error in model.generate: {error_details}")
+            yield f"❌ Generation error: {str(e)}"
+            return
 
 model_handler = None
 
@@ -147,116 +197,113 @@ def get_model_handler():
         model_handler = ModelHandler(MODEL_PATH)
     return model_handler
 
-def _history_to_messages(history):
-    """
-    将 Gradio 的 Tuple 历史 [[user, bot], ...] 转换为 OpenAI 格式的消息列表。
-    以便发送给模型。
-    """
+def _convert_history_to_messages_format(history):
+    """将旧格式的 Chatbot history 转换为新格式的 messages"""
     messages = []
-    
     for pair in history:
-        user_msg, bot_msg = pair
-        
-        # --- 处理用户消息 ---
-        if user_msg:
-            # 检查是否是文件路径（图片）
-            # Gradio 中图片通常是临时路径，或者 http 链接
-            is_image = False
+        if isinstance(pair, list) and len(pair) >= 2:
+            user_msg = pair[0]
+            assistant_msg = pair[1] if len(pair) > 1 else ""
+            
+            # 处理用户消息
+            user_content = []
             if isinstance(user_msg, str):
-                if os.path.exists(user_msg) or user_msg.startswith("http"):
-                    # 简单的判断：如果是现有路径或者是URL，且看起来像图片
-                    lower_msg = user_msg.lower()
-                    if any(lower_msg.endswith(ext) for ext in ['.jpg', '.png', '.jpeg', '.webp', '.bmp']):
-                        is_image = True
+                user_content.append({"type": "text", "text": user_msg})
+            elif isinstance(user_msg, tuple):
+                # 旧格式可能是 (text, image) 或 (image, text)
+                for item in user_msg:
+                    if isinstance(item, str):
+                        if os.path.exists(item) or any(item.lower().endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']):
+                            user_content.append({"type": "image", "image": item})
+                        else:
+                            user_content.append({"type": "text", "text": item})
+            elif isinstance(user_msg, list):
+                # 可能是新格式的内容列表
+                user_content = user_msg
             
-            # 构建 User Content
-            if is_image:
-                # 这是一个独立的图片消息
-                # 注意：为了模型效果，最好将图片和紧接着的文本合并。
-                # 但为了代码简单，我们先作为独立消息，大多数 VLM 也能处理。
-                messages.append({
-                    "role": "user", 
-                    "content": [{"type": "image", "image": user_msg}]
-                })
-            else:
-                # 这是一个文本消息
-                # 如果上一条也是 user 且是 image，尝试合并（可选，这里简单起见直接 append）
-                messages.append({
-                    "role": "user", 
-                    "content": [{"type": "text", "text": str(user_msg)}]
-                })
-        
-        # --- 处理机器人消息 ---
-        if bot_msg:
-            messages.append({
-                "role": "assistant", 
-                "content": [{"type": "text", "text": str(bot_msg)}]
-            })
+            if user_content:
+                messages.append({"role": "user", "content": user_content})
             
+            # 处理助手消息
+            if assistant_msg and isinstance(assistant_msg, str):
+                messages.append({"role": "assistant", "content": assistant_msg})
+        elif isinstance(pair, dict):
+            # 如果已经是新格式，直接使用
+            messages.append(pair)
     return messages
 
-# ==========================================
+def _format_user_input_for_chatbot(text, files):
+    """格式化用户输入为 Chatbot 可显示的格式"""
+    if files and text:
+        # 有图片和文本，返回元组格式
+        return (text, *files)
+    elif files:
+        # 只有图片
+        return files[0] if len(files) == 1 else tuple(files)
+    else:
+        # 只有文本
+        return text
+
 @gpu_decorator
-def respond(user_input, history, temp, tokens):
+def respond(user_msg, history, temp, tokens):
     """
-    user_input: MultimodalTextbox 返回的字典 {'text': '...', 'files': [...]}
-    history: 这里的 history 是 Gradio 自动维护的 [{'role': 'user', ...}, ...] 列表
+    user_msg: Gradio MultimodalTextbox 返回的字典 {'text': '...', 'files': ['...']}
+    history: Gradio Chatbot (type='messages') 维护的列表 [{'role': 'user', 'content': ...}, ...]
     """
     
-    # 1. 构建当前用户的消息对象
+    # 1. 解析用户输入，构建符合 OpenAI 格式的 User Message
     user_content = []
     
-    # 处理图片
-    files = user_input.get("files", [])
+    # 处理图片文件
+    files = user_msg.get("files", [])
     for file_path in files:
         user_content.append({"type": "image", "image": file_path})
     
     # 处理文本
-    text = user_input.get("text", "")
+    text = user_msg.get("text", "")
     if text:
         user_content.append({"type": "text", "text": text})
 
-    # 如果没有内容，直接返回
     if not user_content:
         yield history, gr.MultimodalTextbox(interactive=True)
         return
 
-    # 2. 将用户消息加入历史
-    # 注意：history 必须是 [{'role': 'user', 'content': [...]}, ...] 格式
-    history.append({"role": "user", "content": user_content})
+    # 2. 将当前用户消息加入历史记录
+    new_message = {"role": "user", "content": user_content}
+    history.append(new_message)
     
-    # 立即更新 UI，清空输入框
+    # 3. 立即 yield 更新 UI（显示用户消息），同时清空输入框
     yield history, gr.MultimodalTextbox(value=None, interactive=False)
     
+    # 4. 准备调用模型
     try:
         handler = get_model_handler()
         
-        # 3. 预先加入一个空的助手消息，用于流式显示
+        # 预先加入一个空的 Assistant 消息用于流式填充
         history.append({"role": "assistant", "content": ""})
         
-        # 4. 调用模型
-        # 我们传入 history 的副本（不包含刚才加的空 assistant），以免污染
-        input_messages = copy.deepcopy(history[:-1])
+        # 调用 predict (注意：这里直接传 history 即可，因为 history 已经是完整的上下文)
+        # 我们传入 history 的深拷贝以防修改影响 UI，或者直接传引用如果 predict 内部做了处理
+        # 这里为了安全，我们只把 history 传进去，predict 内部会处理 sys_prompt 的追加逻辑
+        import copy
+        messages_payload = copy.deepcopy(history[:-1]) # 去掉刚才加的空 assistant
         
-        full_response = ""
-        for chunk in handler.predict(input_messages, temp, tokens):
-            full_response += chunk
+        for chunk in handler.predict(messages_payload, temp, tokens):
             # 实时更新最后一条消息的内容
-            history[-1]["content"] = full_response
+            history[-1]["content"] = chunk
             yield history, gr.MultimodalTextbox(interactive=False)
             
     except Exception as e:
         import traceback
         traceback.print_exc()
-        # 出错时显示错误信息
+        # 发生错误时，追加错误信息
         if history and history[-1]["role"] == "assistant":
             history[-1]["content"] += f"\n❌ Error: {str(e)}"
         else:
             history.append({"role": "assistant", "content": f"❌ Error: {str(e)}"})
-            
         yield history, gr.MultimodalTextbox(interactive=True)
     
-    # 最后恢复输入框
+    # 最后恢复输入框可交互
     yield history, gr.MultimodalTextbox(interactive=True)
 
 def create_chat_ui():