Update app.py

app.py

@@ -126,58 +126,35 @@ class TextToSQLSystem:
                     print(f"  - {col['name']} ({col['type']})")
             print("=" * 50)
     
+    # in class TextToSQLSystem:
+
     def _load_gguf_model(self):
-        """載入 GGUF 模型，失敗則使用 Transformers 備用方案"""
-        # 先嘗試原本的 GGUF 載入方式
+        """載入 GGUF 模型，使用更穩定、簡潔的參數"""
         try:
-            self._log("載入 GGUF 模型...")
+            self._log("載入 GGUF 模型 (使用穩定性參數)...")
             model_path = hf_hub_download(
                 repo_id=GGUF_REPO_ID,
                 filename=GGUF_FILENAME,
-                repo_type="dataset",
-                force_download=True
+                repo_type="dataset"
             )
             
-            # 你原本的載入參數
+            # 使用一組更基礎、更穩定的參數來載入模型
             self.llm = Llama(
                 model_path=model_path,
-                n_ctx=1024,      # 增加到 1024 或 2048
-                n_threads=4,
-                n_batch=64,      # 減少批次大小
-                verbose=False,
-                use_mmap=True,
-                use_mlock=False,
-                n_gpu_layers=0,
-                max_tokens=150   # 限制最大生成長度
+                n_ctx=2048,      # 將上下文增加到 2048 以確保 Prompt 不會超長
+                n_threads=4,     # 保持 4 線程
+                n_batch=512,     # 建議值
+                verbose=False,   # 設為 False 避免 llama.cpp 本身的日誌干擾
+                n_gpu_layers=0   # 確認在 CPU 上運行
             )
             
-            # 測試是否能正常生成
-            test_output = self.llm("SELECT", max_tokens=5, temperature=0.1)
+            # 簡單測試模型是否能回應
+            self.llm("你好", max_tokens=3)
             self._log("✅ GGUF 模型載入成功")
-            return
             
         except Exception as e:
             self._log(f"❌ GGUF 載入失敗: {e}", "ERROR")
-            
-        # GGUF 失敗，使用 Transformers 載入你的微調模型
-        try:
-            self._log("改用 Transformers 載入微調模型...")
-            from transformers import AutoModelForCausalLM, AutoTokenizer
-            import torch
-            
-            self.transformers_tokenizer = AutoTokenizer.from_pretrained(FINETUNED_MODEL_PATH)
-            self.transformers_model = AutoModelForCausalLM.from_pretrained(
-                FINETUNED_MODEL_PATH,
-                torch_dtype=torch.float32,
-                device_map="cpu",
-                trust_remote_code=True
-            )
-            
-            self.llm = "transformers"  # 標記使用 transformers
-            self._log("✅ Transformers 模型載入成功")
-            
-        except Exception as e:
-            self._log(f"❌ Transformers 載入也失敗: {e}", "ERROR")
+            self._log("系統將無法生成 SQL。請檢查模型檔案或 llama-cpp-python 安裝。", "CRITICAL")
             self.llm = None
         
     def _try_gguf_loading(self):
@@ -244,53 +221,41 @@ class TextToSQLSystem:
             self.llm = None
     
     def huggingface_api_call(self, prompt: str) -> str:
-        """使用更嚴格的長度限制"""
+        """調用 GGUF 模型，並加入詳細的原始輸出日誌"""
         if self.llm is None:
+            self._log("模型未載入，返回 fallback SQL。", "ERROR")
             return self._generate_fallback_sql(prompt)
         
         try:
-            # 確保 prompt 不超過限制
-            if len(prompt) > 600:
-                prompt = prompt[:600] + "..."
+            # GGUF 模型呼叫
+            output = self.llm(
+                prompt,
+                max_tokens=150,       # 給予足夠的生成長度
+                temperature=0.1,
+                top_p=0.9,
+                echo=False,
+                # 暫時移除 stop 參數，觀察最原始的輸出
+                # stop=["```", ";", "\n\n", "</s>"],
+            )
             
-            if self.llm == "transformers":
-                inputs = self.transformers_tokenizer(prompt, return_tensors="pt", 
-                                                   truncation=True, max_length=400)  # 減少輸入長度
-                
-                with torch.no_grad():
-                    outputs = self.transformers_model.generate(
-                        inputs.input_ids,
-                        attention_mask=inputs.attention_mask,
-                        max_new_tokens=80,    # 減少生成長度
-                        temperature=0.1,
-                        do_sample=True,
-                        top_p=0.9,
-                        pad_token_id=self.transformers_tokenizer.eos_token_id,
-                        eos_token_id=self.transformers_tokenizer.eos_token_id
-                    )
-                
-                generated_text = self.transformers_tokenizer.decode(
-                    outputs[0][inputs.input_ids.shape[1]:], 
-                    skip_special_tokens=True
-                )
-                
-                return generated_text.strip()
+            # --- 關鍵除錯步驟 ---
+            # 印出 llama-cpp-python 返回的完整、原始的 dictionary
+            self._log(f"🧠 模型原始輸出 (Raw Output): {output}", "DEBUG")
             
+            if output and "choices" in output and len(output["choices"]) > 0:
+                # 從原始輸出中提取文本
+                generated_text = output["choices"][0]["text"]
+                self._log(f"📝 提取出的生成文本: {generated_text.strip()}", "DEBUG")
+                return generated_text.strip()
             else:
-                # GGUF 模型
-                output = self.llm(
-                    prompt,
-                    max_tokens=100,       # 減少最大生成長度
-                    temperature=0.1,
-                    top_p=0.9,
-                    stop=["```", ";", "\n\n", "</s>"],
-                    echo=False
-                )
-                return output["choices"][0]["text"].strip()
+                self._log("❌ 模型的原始輸出格式不正確或為空。", "ERROR")
+                return "" # 返回空字串，讓後續流程處理
                 
         except Exception as e:
-            self._log(f"❌ 生成失敗: {e}", "ERROR")
-            return self._generate_fallback_sql(prompt)
+            self._log(f"❌ 模型生成過程中發生嚴重錯誤: {e}", "CRITICAL")
+            import traceback
+            self._log(traceback.format_exc(), "DEBUG") # 印出詳細的錯誤堆疊
+            return "" # 返回空字串
         
     def _load_gguf_model_fallback(self, model_path):
         """備用載入方式"""