+-------------------+     +-------------------+     +-------------------+     +-------------------+
| 輸入文本序列        |     | 計算每個位置        |     | 計算平均負          |     | 取指數得           |
| "今天天氣很好"      | --> | 條件概率           | --> | 對數概率            | --> | 困惑度值           |
|                   |     | P(w_i|w_<i)       |     | -1/N Σ log P(...) |     | exp(平均值)        |
+-------------------+     +-------------------+     +-------------------+     +-------------------+
         |                         |                         |                         |
         v                         v                         v                         v
+-------------------+     +-------------------+     +-------------------+     +-------------------+
| 分詞:              |    | P("今天"|開始)=0.4  |     | -1/3 [log(0.4) +  |     | PPL = exp(0.706)  |
| ["今天", "天氣",    |    | P("天氣"|"今天")=0.6|     |   log(0.6) +      |     | = 2.027           |
| "很好"]            |    | P("很好"|"今天 天氣")=0.5| |   log(0.5) +      |     |                   |
| N=3               |    |                    |     | = -1/3 [-0.9163 +  |    |                   | 
+-------------------+     +-------------------+     | -0.5108 + -0.6931] |    +-------------------+
                                                    | = -1/3 × -2.1202   |
                                                    | = 0.7067           |
                                                    +-------------------+

import requests
import json
import math
import os

class QwenPerplexityCalculator:
    def __init__(self, api_key):
        self.api_key = api_key
        self.api_url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
    
    def calculate_perplexity_process(self, text, probabilities):
        """
        使用Qwen API模擬困惑度計算過程
        
        參數:
            text: 要計算困惑度的文本
            probabilities: 各位置的條件概率值列表
        """
        # 構建詳細的prompt，要求模型按照指定流程計算困惑度
        prompt = f"""請按照以下步驟計算文本的困惑度(PPL)，使用我提供的概率值：

文本: "{text}"
條件概率值:
P("今天" | <開始>) = {probabilities[0]}
P("天氣" | "今天") = {probabilities[1]}
P("很好" | "今天 天氣") = {probabilities[2]}

請逐步計算並解釋：
1. 計算對數概率和：log({probabilities[0]}) + log({probabilities[1]}) + log({probabilities[2]})
2. 計算平均負對數概率：- (對數概率和) / N (N=3)
3. 計算困惑度：exp(平均負對數概率)

請詳細展示每一步的計算過程和結果，最後給出完整的困惑度值。"""

        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        payload = {
            "model": "qwen-max",
            "input": {
                "messages": [{"role": "user", "content": prompt}]
            },
            "parameters": {
                "result_format": "text",
                "max_tokens": 800,
                "temperature": 0.1
            }
        }
        
        try:
            response = requests.post(self.api_url, headers=headers, data=json.dumps(payload))
            result = response.json()
            
            if "output" in result and "text" in result["output"]:
                return result["output"]["text"].strip()
            return None
        except Exception as e:
            print(f"API調用失敗: {e}")
            return None
    
    def manual_calculation(self, text, probabilities):
        """
        手動計算困惑度過程，用於驗證
        """
        print(f"文本: '{text}'")
        print("\n1. 計算每個位置的條件概率:")
        for i, prob in enumerate(probabilities):
            if i == 0:
                print(f"   P('{text.split()[i]}' | <開始>) = {prob}")
            else:
                context = " ".join(text.split()[:i])
                print(f"   P('{text.split()[i]}' | '{context}') = {prob}")
        
        print("\n2. 計算對數概率和:")
        log_probs = [math.log(p) for p in probabilities]
        log_sum = sum(log_probs)
        log_str = " + ".join([f"log({p})" for p in probabilities])
        print(f"   {log_str} = {log_str.replace('log', str(round(math.log(probabilities[0]), 2))).replace('log', str(round(math.log(probabilities[1]), 2))).replace('log', str(round(math.log(probabilities[2]), 2)))} = {round(log_sum, 2)}")
        
        print("\n3. 計算平均負對數概率:")
        n = len(probabilities)
        avg_neg_log_prob = -log_sum / n
        print(f"   -({round(log_sum, 2)}) / {n} = {round(avg_neg_log_prob, 2)}")
        
        print("\n4. 計算困惑度:")
        perplexity = math.exp(avg_neg_log_prob)
        print(f"   exp({round(avg_neg_log_prob, 2)}) = {round(perplexity, 2)}")
        
        return perplexity

# 使用示例
if __name__ == "__main__":
    # 初始化計算器
    calculator = QwenPerplexityCalculator(os.environ.get("DASHSCOPE_API_KEY"))
    
    # 定義文本和概率值
    text = "今天 天氣 很好"
    probabilities = [0.4, 0.6, 0.5]
    
    print("使用Qwen API模擬困惑度計算過程:")
    print("=" * 50)
    
    # 使用Qwen API獲取計算過程
    process = calculator.calculate_perplexity_process(text, probabilities)
    if process:
        print(process)
    else:
        print("API調用失敗，使用手動計算")
    
    print("\n" + "=" * 50)
    print("手動計算驗證:")
    print("=" * 50)
    
    # 手動計算驗證
    final_ppl = calculator.manual_calculation(text, probabilities)
    print(f"\n最終困惑度: {final_ppl:.2f}")

import requests
import json
import re
import os

class QwenIntrinsicEvaluator:
    def __init__(self, api_key):
        self.api_key = api_key
        self.api_url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
    
    def estimate_perplexity_with_details(self, text):
        """
        估算文本困惑度並返回詳細計算過程
        
        參數:
            text: 要計算困惑度的文本
        
        返回:
            包含困惑度值和計算細節的字典
        """
        # 構建詳細的prompt，要求模型解釋計算過程
        prompt = f"""作為語言模型專家，請分析以下文本的語言建模難度，並估算其困惑度(PPL)值。
請詳細解釋你的計算過程，包括以下內容：
1. 文本的語言複雜性分析
2. 詞彙的常見程度評估
3. 句法結構的複雜性
4. 最終估算的困惑度值及其解釋

文本: "{text}"

請按以下格式回覆：
【文本分析】
[對文本複雜性的分析]

【詞彙評估】
[對詞彙常見程度的評估]

【句法分析】
[對句法複雜性的分析]

【困惑度估算】
估算值: [數值]
解釋: [對估算值的解釋]
"""
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        payload = {
            "model": "qwen-max",
            "input": {
                "messages": [{"role": "user", "content": prompt}]
            },
            "parameters": {
                "result_format": "text",
                "max_tokens": 800,
                "temperature": 0.1
            }
        }
        
        try:
            response = requests.post(self.api_url, headers=headers, data=json.dumps(payload))
            result = response.json()
            
            if "output" in result and "text" in result["output"]:
                response_text = result["output"]["text"].strip()
                
                # 解析響應內容
                details = self._parse_response_details(response_text)
                
                # 提取困惑度值
                match = re.search(r"估算值:\s*([\d\.]+)", response_text)
                if match:
                    details['perplexity'] = float(match.group(1))
                else:
                    # 備用方法：嘗試從文本中提取任何數字
                    num_match = re.search(r"(\d+\.\d+|\d+)", response_text)
                    if num_match:
                        details['perplexity'] = float(num_match.group())
                    else:
                        details['perplexity'] = None
                
                details['full_response'] = response_text
                return details
            return None
        except Exception as e:
            print(f"API調用失敗: {e}")
            return None
    
    def _parse_response_details(self, response_text):
        """解析模型響應中的詳細信息"""
        details = {
            'text_analysis': '',
            'vocabulary_assessment': '',
            'syntax_analysis': '',
            'explanation': ''
        }
        
        # 使用正則表達式提取各個部分
        text_analysis_match = re.search(r"【文本分析】\s*(.*?)(?=【|$)", response_text, re.DOTALL)
        vocab_match = re.search(r"【詞彙評估】\s*(.*?)(?=【|$)", response_text, re.DOTALL)
        syntax_match = re.search(r"【句法分析】\s*(.*?)(?=【|$)", response_text, re.DOTALL)
        explanation_match = re.search(r"解釋:\s*(.*?)(?=【|$)", response_text, re.DOTALL)
        
        if text_analysis_match:
            details['text_analysis'] = text_analysis_match.group(1).strip()
        if vocab_match:
            details['vocabulary_assessment'] = vocab_match.group(1).strip()
        if syntax_match:
            details['syntax_analysis'] = syntax_match.group(1).strip()
        if explanation_match:
            details['explanation'] = explanation_match.group(1).strip()
        
        return details

# 使用示例
if __name__ == "__main__":
    evaluator = QwenIntrinsicEvaluator(os.environ.get("DASHSCOPE_API_KEY"))
    text = "語言模型的評測是一個重要的研究領域"
    
    # 獲取詳細的困惑度分析
    result = evaluator.estimate_perplexity_with_details(text)
    
    if result and 'perplexity' in result:
        print(f"文本: '{text}'")
        print(f"估算困惑度值: {result['perplexity']}")
        print("\n=== 詳細分析 ===")
        print(f"文本分析: {result.get('text_analysis', '無')}")
        print(f"詞彙評估: {result.get('vocabulary_assessment', '無')}")
        print(f"句法分析: {result.get('syntax_analysis', '無')}")
        print(f"解釋: {result.get('explanation', '無')}")
        
        print("\n=== 完整響應 ===")
        print(result.get('full_response', '無'))
    else:
        print("無法計算困惑度")

文本: '語言模型的評測是一個重要的研究領域'
估算困惑度值: 1.5

=== 詳細分析 ===
文本分析: 該句"語言模型的評測是一個重要的研究領域"屬於中文，句子結構相對簡單直接，沒有使用複雜的修辭手法或生僻詞彙。從語義上看，這句話 
表達了一個明確的觀點，即“語言模型的評測”在學術界佔據着重要地位。整體而言，對於具有一定中文基礎的人來説理解起來並不困難。
詞彙評估: - “語言模型”：這是一個專業術語，在自然語言處理（NLP）領域內較為常見。
- “評測”：普通詞彙，但在此處特指對某種技術或方法進行評價和測試的過程。
- “是”、“一個”、“的”等詞為常用連接詞或助詞。
- “重要”、“研究”、“領域”均為日常交流中頻繁出現的詞語。
綜上所述，除了“語言模型”可能需要特定背景知識才能完全理解外，其他詞彙都比較普遍易懂。
句法分析: 本句採用了典型的主謂賓結構：“[語言模型的評測] [是] [一個重要的研究領域]”。其中，“語言模型的評測”作為整個句子的主題；“是”起到 
連接作用；而“一個重要的研究領域”則構成了句子的核心信息部分。這種構造方式符合漢語的基本語法規範，邏輯清晰，易於解析。
解釋: 困惑度（Perplexity, PPL）是用來衡量語言模型預測下一個單詞能力的一個指標，數值越低表示模型對該文本的理解越好。考慮到上述分析結果——即文本內容簡潔明瞭、大部分詞彙通俗易懂且句式結構簡單——可以推測出對於訓練良好的現代中文語言模型來説，這段話應該很容易被準確地理解和生成 
。因此，我估計其PPL值大約位於1.5到2.0之間，表明模型能夠以較高概率正確預測出每個詞。當然，實際數值還需通過具體實驗來確定。

import requests
import json
import numpy as np
import pandas as pd
from sentence_transformers import SentenceTransformer
import faiss
import re
from typing import List, Dict, Any
import time
import os

class QwenAccuracyEvaluator:
    def __init__(self, api_key: str, knowledge_base: List[str] = None):
        """
        基於Qwen API的外在評測準確率計算系統
        
        參數:
            api_key: Qwen API密鑰
            knowledge_base: 知識庫文本列表（可選，用於檢索增強）
        """
        self.api_key = api_key
        self.api_url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
        
        # 如果有知識庫，構建Faiss索引
        if knowledge_base:
            self.knowledge_base = knowledge_base
            self.embedder = SentenceTransformer('D:/modelscope/hub/models/sentence-transformers/all-MiniLM-L6-v2')
            self._build_faiss_index()
            self.use_rag = True
        else:
            self.use_rag = False
        
        # 測試數據集 - 問答對
        self.qa_test_set = [
            {
                "id": 1,
                "question": "Python中如何創建一個空列表？",
                "expected_answer": "可以使用方括號 [] 或 list() 函數創建空列表",
                "acceptable_variations": [
                    "使用 [] 創建空列表",
                    "用 list() 創建空列表",
                    "空列表可以通過 [] 或 list() 創建"
                ]
            },
            {
                "id": 2,
                "question": "什麼是機器學習？",
                "expected_answer": "機器學習是人工智能的一個子領域，使計算機能夠從數據中學習而不需要明確編程",
                "acceptable_variations": [
                    "機器學習是AI的一個分支，讓計算機從數據中學習",
                    "ML是計算機通過數據自動學習和改進的技術"
                ]
            },
            {
                "id": 3,
                "question": "如何在Python中打印'Hello, World!'？",
                "expected_answer": "使用 print('Hello, World!')",
                "acceptable_variations": [
                    "print('Hello, World!')",
                    "使用print函數打印Hello, World!"
                ]
            }
        ]
    
    def _build_faiss_index(self):
        """構建Faiss向量索引（如果使用知識庫）"""
        if not hasattr(self, 'knowledge_base'):
            return
            
        # 生成知識庫文本的向量
        knowledge_vectors = self.embedder.encode(self.knowledge_base)
        self.dimension = knowledge_vectors.shape[1]
        
        # 創建Faiss索引
        self.index = faiss.IndexFlatL2(self.dimension)
        self.index.add(knowledge_vectors.astype('float32'))
        
        print(f"知識庫索引構建完成，包含 {len(self.knowledge_base)} 條知識")
    
    def _retrieve_relevant_texts(self, query: str, top_k: int = 3) -> List[str]:
        """檢索相關文本（如果使用知識庫）"""
        if not hasattr(self, 'index'):
            return []
            
        # 生成查詢向量
        query_vector = self.embedder.encode([query])
        
        # 檢索相似文本
        D, I = self.index.search(query_vector.astype('float32'), top_k)
        
        retrieved_texts = []
        for i in range(top_k):
            if I[0][i] < len(self.knowledge_base):
                retrieved_texts.append(self.knowledge_base[I[0][i]])
        
        return retrieved_texts
    
    def call_qwen_api(self, prompt: str, max_tokens: int = 500) -> str:
        """調用Qwen API生成文本"""
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        payload = {
            "model": "qwen-max",  # 可以根據需要選擇不同模型
            "input": {
                "messages": [
                    {
                        "role": "user",
                        "content": prompt
                    }
                ]
            },
            "parameters": {
                "result_format": "text",
                "max_tokens": max_tokens,
                "temperature": 0.3  # 降低隨機性，提高確定性
            }
        }
        
        try:
            response = requests.post(self.api_url, headers=headers, data=json.dumps(payload))
            response.raise_for_status()
            result = response.json()
            
            if "output" in result and "text" in result["output"]:
                return result["output"]["text"].strip()
            return None
        except Exception as e:
            print(f"API調用失敗: {e}")
            return None
    
    def generate_answer(self, question: str) -> str:
        """生成答案"""
        if self.use_rag:
            # 使用檢索增強生成(RAG)
            relevant_texts = self._retrieve_relevant_texts(question)
            context = "\n".join(relevant_texts)
            
            prompt = f"""基於以下上下文信息回答問題。如果信息不足，請明確説明。

上下文：
{context}

問題：
{question}

請提供準確、簡潔的答案："""
        else:
            # 直接回答問題
            prompt = f"""請回答以下問題。提供準確、完整的回答。

問題：{question}

回答："""
        
        return self.call_qwen_api(prompt)
    
    def evaluate_accuracy(self, generated_answer: str, expected_answer: str, 
                         acceptable_variations: List[str] = None) -> Dict[str, Any]:
        """
        評估生成答案的準確率
        
        參數:
            generated_answer: 模型生成的答案
            expected_answer: 期望的標準答案
            acceptable_variations: 可接受的答案變體列表
        
        返回:
            包含準確率評估結果的字典
        """
        if not generated_answer:
            return {
                "is_correct": False,
                "confidence": 0.0,
                "match_type": "no_answer",
                "explanation": "模型未生成答案"
            }
        
        # 標準化答案（小寫、去除標點）
        def normalize_text(text):
            text = text.lower()
            text = re.sub(r'[^\w\s]', '', text)  # 移除標點符號
            return text.strip()
        
        gen_norm = normalize_text(generated_answer)
        exp_norm = normalize_text(expected_answer)
        
        # 1. 精確匹配檢查
        if gen_norm == exp_norm:
            return {
                "is_correct": True,
                "confidence": 1.0,
                "match_type": "exact",
                "explanation": "生成答案與標準答案完全匹配"
            }
        
        # 2. 檢查可接受的變體
        if acceptable_variations:
            for variation in acceptable_variations:
                if gen_norm == normalize_text(variation):
                    return {
                        "is_correct": True,
                        "confidence": 0.9,
                        "match_type": "acceptable_variation",
                        "explanation": "生成答案與可接受變體匹配"
                    }
        
        # 3. 關鍵詞匹配檢查
        expected_keywords = set(exp_norm.split())
        generated_keywords = set(gen_norm.split())
        common_keywords = expected_keywords & generated_keywords
        
        if len(common_keywords) >= len(expected_keywords) * 0.7:  # 70%關鍵詞匹配
            keyword_coverage = len(common_keywords) / len(expected_keywords)
            return {
                "is_correct": True,
                "confidence": keyword_coverage * 0.8,  # 最高0.8置信度
                "match_type": "keyword_based",
                "explanation": f"關鍵詞匹配度: {keyword_coverage:.2f}"
            }
        
        # 4. 使用Qwen API進行語義評估
        evaluation_prompt = f"""請判斷以下兩個答案是否在語義上等價：

答案1: {expected_answer}
答案2: {generated_answer}

請只回復"是"或"否"，不要包含其他內容。"""
        
        semantic_eval = self.call_qwen_api(evaluation_prompt, max_tokens=10)
        
        if semantic_eval and "是" in semantic_eval:
            return {
                "is_correct": True,
                "confidence": 0.7,
                "match_type": "semantic",
                "explanation": "語義評估認為答案等價"
            }
        
        # 5. 所有檢查都失敗，答案不正確
        return {
            "is_correct": False,
            "confidence": 0.0,
            "match_type": "incorrect",
            "explanation": "答案不正確"
        }
    
    def run_accuracy_evaluation(self) -> List[Dict[str, Any]]:
        """運行準確率評測"""
        results = []
        correct_count = 0
        
        for test_case in self.qa_test_set:
            print(f"\n處理測試用例 {test_case['id']}: {test_case['question']}")
            
            # 生成答案
            generated_answer = self.generate_answer(test_case['question'])
            if not generated_answer:
                print("生成答案失敗")
                results.append({
                    "test_case_id": test_case["id"],
                    "question": test_case["question"],
                    "generated_answer": None,
                    "expected_answer": test_case["expected_answer"],
                    "is_correct": False,
                    "confidence": 0.0,
                    "match_type": "no_answer"
                })
                continue
            
            print(f"生成答案: {generated_answer}")
            
            # 評估準確率
            accuracy_result = self.evaluate_accuracy(
                generated_answer, 
                test_case["expected_answer"],
                test_case.get("acceptable_variations", [])
            )
            
            # 更新正確計數
            if accuracy_result["is_correct"]:
                correct_count += 1
            
            # 保存結果
            result = {
                "test_case_id": test_case["id"],
                "question": test_case["question"],
                "generated_answer": generated_answer,
                "expected_answer": test_case["expected_answer"],
                "is_correct": accuracy_result["is_correct"],
                "confidence": accuracy_result["confidence"],
                "match_type": accuracy_result["match_type"],
                "explanation": accuracy_result["explanation"]
            }
            
            results.append(result)
            
            # 打印當前結果
            status = "正確" if accuracy_result["is_correct"] else "錯誤"
            print(f"評估結果: {status} (置信度: {accuracy_result['confidence']:.2f})")
            print(f"匹配類型: {accuracy_result['match_type']}")
            
            # 添加延遲避免API限制
            time.sleep(1)
        
        # 計算總體準確率
        total_cases = len(results)
        accuracy = correct_count / total_cases if total_cases > 0 else 0
        
        return results, accuracy
    
    def generate_accuracy_report(self, results: List[Dict[str, Any]], accuracy: float) -> str:
        """生成準確率評測報告"""
        if not results:
            return "無評測結果"
        
        # 創建報告
        report_lines = [
            "Qwen API外在評測準確率報告",
            "=" * 60,
            f"評測時間: {time.strftime('%Y-%m-%d %H:%M:%S')}",
            f"測試用例數量: {len(results)}",
            f"正確回答數量: {sum(1 for r in results if r['is_correct'])}",
            f"總體準確率: {accuracy:.2%}",
            "\n詳細結果:",
            "=" * 60
        ]
        
        for result in results:
            status = "✓" if result["is_correct"] else "✗"
            report_lines.extend([
                f"\n{status} 用例 {result['test_case_id']}:",
                f"問題: {result['question']}",
                f"生成答案: {result['generated_answer']}",
                f"期望答案: {result['expected_answer']}",
                f"匹配類型: {result['match_type']}",
                f"置信度: {result['confidence']:.2f}",
                f"解釋: {result['explanation']}"
            ])
        
        # 添加匹配類型統計
        match_types = {}
        for result in results:
            match_type = result["match_type"]
            match_types[match_type] = match_types.get(match_type, 0) + 1
        
        report_lines.extend([
            "\n匹配類型統計:",
            "=" * 60
        ])
        
        for match_type, count in match_types.items():
            report_lines.append(f"{match_type}: {count}次")
        
        return "\n".join(report_lines)

# 使用示例
if __name__ == "__main__":
    # 配置參數
    API_KEY = os.environ.get("DASHSCOPE_API_KEY")
    
    # 可選的知識庫數據
    knowledge_base = [
        "Python中可以使用方括號[]或list()函數創建空列表",
        "機器學習是人工智能的一個子領域，使計算機能夠從數據中學習",
        "在Python中使用print()函數可以輸出文本到控制枱"
    ]
    
    # 初始化評測器（可以選擇是否使用知識庫）
    evaluator = QwenAccuracyEvaluator(API_KEY, knowledge_base)
    
    # 運行準確率評測
    print("開始準確率評測...")
    results, accuracy = evaluator.run_accuracy_evaluation()
    
    # 生成報告
    if results:
        report = evaluator.generate_accuracy_report(results, accuracy)
        print(report)
        
        # 保存報告到文件
        with open('qwen_accuracy_report.txt', 'w', encoding='utf-8') as f:
            f.write(report)
        print("\n準確率報告已保存至 qwen_accuracy_report.txt")
    else:
        print("評測失敗，無結果生成")

知識庫索引構建完成，包含 3 條知識
開始準確率評測...

處理測試用例 1: Python中如何創建一個空列表？
生成答案: 在Python中，可以通過以下兩種方式創建一個空列表：

1. 使用方括號 `[]`，例如：`my_list = []`
2. 使用 `list()` 函數，例如：`my_list = list()`
評估結果: 正確 (置信度: 0.70)
匹配類型: semantic

處理測試用例 2: 什麼是機器學習？
生成答案: 機器學習是人工智能的一個子領域，它使計算機能夠通過從數據中學習來改進其性能和決策能力，而無需進行明確的編
程。
評估結果: 正確 (置信度: 0.70)
匹配類型: semantic

處理測試用例 3: 如何在Python中打印'Hello, World!'？
生成答案: 在Python中打印'Hello, World!'，你可以使用以下代碼：

```python
print('Hello, World!')
```
評估結果: 正確 (置信度: 0.70)
匹配類型: semantic
Qwen API外在評測準確率報告
============================================================
評測時間: 2025-09-08 19:56:45
測試用例數量: 3
正確回答數量: 3
總體準確率: 100.00%

詳細結果:
============================================================

✓ 用例 1:
問題: Python中如何創建一個空列表？
生成答案: 在Python中，可以通過以下兩種方式創建一個空列表：

1. 使用方括號 `[]`，例如：`my_list = []`
2. 使用 `list()` 函數，例如：`my_list = list()`
期望答案: 可以使用方括號 [] 或 list() 函數創建空列表
匹配類型: semantic
置信度: 0.70
解釋: 語義評估認為答案等價

✓ 用例 2:
問題: 什麼是機器學習？
生成答案: 機器學習是人工智能的一個子領域，它使計算機能夠通過從數據中學習來改進其性能和決策能力，而無需進行明確的編
程。
期望答案: 機器學習是人工智能的一個子領域，使計算機能夠從數據中學習而不需要明確編程
匹配類型: semantic
置信度: 0.70
解釋: 語義評估認為答案等價

✓ 用例 3:
問題: 如何在Python中打印'Hello, World!'？
生成答案: 在Python中打印'Hello, World!'，你可以使用以下代碼：

```python
print('Hello, World!')
```
期望答案: 使用 print('Hello, World!')
匹配類型: semantic
置信度: 0.70
解釋: 語義評估認為答案等價

匹配類型統計:
============================================================
semantic: 3次

準確率報告已保存至 qwen_accuracy_report.txt

if gen_norm == exp_norm:
    return {
        "is_correct": True,
        "confidence": 1.0,
        "match_type": "exact",
        "explanation": "生成答案與標準答案完全匹配"
    }

for variation in acceptable_variations:
    if gen_norm == normalize_text(variation):
        return {
            "is_correct": True,
            "confidence": 0.9,
            "match_type": "acceptable_variation",
            "explanation": "生成答案與可接受變體匹配"
        }

if len(common_keywords) >= len(expected_keywords) * 0.7:
    keyword_coverage = len(common_keywords) / len(expected_keywords)
    return {
        "is_correct": True,
        "confidence": keyword_coverage * 0.8,
        "match_type": "keyword_based",
        "explanation": f"關鍵詞匹配度: {keyword_coverage:.2f}"
    }

evaluation_prompt = f"""請判斷以下兩個答案是否在語義上等價：
答案1: {expected_answer}
答案2: {generated_answer}
請只回復"是"或"否"，不要包含其他內容。"""

semantic_eval = self.call_qwen_api(evaluation_prompt, max_tokens=10)