# 传统NLP示例：TF-IDF + SVM
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.svm import SVC
from sklearn.pipeline import Pipeline

# 构建传统文本分类器
traditional_nlp = Pipeline([
    ('tfidf', TfidfVectorizer(
        max_features=5000,
        ngram_range=(1, 2)
    )),
    ('svm', SVC(
        kernel='linear',
        probability=True
    ))
])

# 训练和预测
traditional_nlp.fit(X_train, y_train)
predictions = traditional_nlp.predict(X_test)

# BERT使用示例
from transformers import BertTokenizer, BertForSequenceClassification
import torch

# 加载预训练BERT
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=2
)

# 文本编码
text = "自然语言处理正在快速发展"
inputs = tokenizer(text, return_tensors='pt', padding=True, truncation=True)

# 模型推理
with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.softmax(outputs.logits, dim=-1)

# GPT-4使用示例
from openai import OpenAI

client = OpenAI(api_key="your-api-key")

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "你是一个NLP专家"},
        {"role": "user", "content": "解释Transformer架构的核心创新"}
    ],
    temperature=0.7,
    max_tokens=500
)

print(response.choices[0].message.content)

import torch
import torch.nn as nn
import math

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
        
    def forward(self, Q, K, V, mask=None):
        batch_size = Q.size(0)
        
        # 线性变换并分头
        Q = self.W_q(Q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(K).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(V).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        
        # 计算注意力
        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        
        attention = torch.softmax(scores, dim=-1)
        output = torch.matmul(attention, V)
        
        # 合并多头
        output = output.transpose(1, 2).contiguous().view(
            batch_size, -1, self.d_model
        )
        
        return self.W_o(output)

class TransformerBlock(nn.Module):
    def __init__(self, d_model, num_heads, ff_dim, dropout=0.1):
        super().__init__()
        self.attention = MultiHeadAttention(d_model, num_heads)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        
        self.ff = nn.Sequential(
            nn.Linear(d_model, ff_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(ff_dim, d_model)
        )
        
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, x, mask=None):
        # 多头注意力
        attn_output = self.attention(x, x, x, mask)
        x = self.norm1(x + self.dropout(attn_output))
        
        # 前馈网络
        ff_output = self.ff(x)
        x = self.norm2(x + self.dropout(ff_output))
        
        return x

# 智能问答系统核心代码
import torch
from transformers import AutoTokenizer, AutoModelForQuestionAnswering
from typing import List, Dict
import numpy as np

class SmartQASystem:
    def __init__(self, model_name="bert-large-uncased-whole-word-masking-finetuned-squad"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForQuestionAnswering.from_pretrained(model_name)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)
    
    def answer_question(self, question: str, context: str) -> Dict:
        """回答基于上下文的问题"""
        # 编码输入
        inputs = self.tokenizer(
            question,
            context,
            return_tensors="pt",
            truncation=True,
            padding=True,
            max_length=512
        ).to(self.device)
        
        # 模型推理
        with torch.no_grad():
            outputs = self.model(**inputs)
        
        # 提取答案
        start_scores = outputs.start_logits
        end_scores = outputs.end_logits
        
        # 找到最佳答案区间
        start_idx = torch.argmax(start_scores)
        end_idx = torch.argmax(end_scores) + 1
        
        # 解码答案
        answer_tokens = inputs["input_ids"][0][start_idx:end_idx]
        answer = self.tokenizer.decode(answer_tokens, skip_special_tokens=True)
        
        # 计算置信度
        confidence = torch.softmax(start_scores, dim=-1)[0][start_idx].item() * \
                     torch.softmax(end_scores, dim=-1)[0][end_idx-1].item()
        
        return {
            "answer": answer,
            "confidence": confidence,
            "start_position": start_idx.item(),
            "end_position": end_idx.item()
        }
    
    def batch_answer(self, questions: List[str], contexts: List[str]) -> List[Dict]:
        """批量回答问题"""
        results = []
        for q, c in zip(questions, contexts):
            result = self.answer_question(q, c)
            results.append(result)
        return results
    
    def evaluate_confidence(self, threshold: float = 0.7):
        """评估答案置信度"""
        def decorator(func):
            def wrapper(*args, **kwargs):
                result = func(*args, **kwargs)
                if result["confidence"] < threshold:
                    result["answer"] = "抱歉，我对这个问题的答案不太确定。"
                return result
            return wrapper
        return decorator

# 使用示例
qa_system = SmartQASystem()

context = """
自然语言处理（NLP）是人工智能的一个子领域，专注于计算机与人类语言之间的交互。
它涉及让计算机理解、解释和生成人类语言。NLP的应用包括机器翻译、情感分析、
聊天机器人、文本摘要等。近年来，基于Transformer的模型如BERT和GPT系列
极大地推动了NLP技术的发展。
"""

question = "NLP的主要应用有哪些？"
result = qa_system.answer_question(question, context)
print(f"问题: {question}")
print(f"答案: {result['answer']}")
print(f"置信度: {result['confidence']:.2%}")

class ConversationalQA:
    def __init__(self):
        self.qa_system = SmartQASystem()
        self.conversation_history = []
        self.max_history = 5
    
    def add_to_history(self, role: str, content: str):
        """添加对话历史"""
        self.conversation_history.append({"role": role, "content": content})
        if len(self.conversation_history) > self.max_history * 2:
            self.conversation_history = self.conversation_history[-self.max_history*2:]
    
    def get_context_from_history(self) -> str:
        """从历史中提取上下文"""
        context_parts = []
        for i, msg in enumerate(self.conversation_history[-self.max_history:]):
            prefix = "用户" if msg["role"] == "user" else "助手"
            context_parts.append(f"{prefix}: {msg['content']}")
        return "\n".join(context_parts)
    
    def ask(self, question: str) -> str:
        """提问并获取回答"""
        # 添加上下文
        self.add_to_history("user", question)
        context = self.get_context_from_history()
        
        # 获取答案
        result = self.qa_system.answer_question(question, context)
        
        # 添加回答到历史
        self.add_to_history("assistant", result["answer"])
        
        return result["answer"]
    
    def clarify_question(self, question: str) -> str:
        """澄清模糊问题"""
        clarification_prompt = f"""
        用户的问题可能不够明确："{question}"
        请生成1-3个澄清问题来帮助理解用户的真实意图。
        """
        
        # 这里可以调用GPT等模型生成澄清问题
        clarifications = [
            "您能具体说明一下您想了解NLP的哪个方面吗？",
            "您是对技术原理感兴趣还是实际应用？",
            "您有特定的NLP任务或场景吗？"
        ]
        
        return random.choice(clarifications)

# 使用示例
conv_qa = ConversationalQA()

# 多轮对话
questions = [
    "什么是NLP？",
    "它有哪些主要应用？",
    "最新的技术进展是什么？"
]

for q in questions:
    print(f"\n用户: {q}")
    answer = conv_qa.ask(q)
    print(f"助手: {answer}")

class NLPEvaluator:
    def __init__(self):
        self.metrics = {}
    
    def calculate_bleu(self, references: List[str], candidates: List[str]) -> float:
        """计算BLEU分数"""
        from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
        
        scores = []
        smoothie = SmoothingFunction().method4
        
        for ref, cand in zip(references, candidates):
            # 将参考文本转换为列表的列表（多个参考）
            ref_tokens = [ref.split()]
            cand_tokens = cand.split()
            
            score = sentence_bleu(
                ref_tokens,
                cand_tokens,
                smoothing_function=smoothie
            )
            scores.append(score)
        
        return np.mean(scores)
    
    def calculate_rouge(self, references: List[str], candidates: List[str]) -> Dict:
        """计算ROUGE分数"""
        from rouge import Rouge
        
        rouge = Rouge()
        scores = rouge.get_scores(candidates, references, avg=True)
        return scores
    
    def calculate_perplexity(self, model, tokenizer, texts: List[str]) -> float:
        """计算困惑度"""
        total_loss = 0
        total_tokens = 0
        
        model.eval()
        with torch.no_grad():
            for text in texts:
                inputs = tokenizer(text, return_tensors="pt", truncation=True)
                inputs = {k: v.to(model.device) for k, v in inputs.items()}
                
                outputs = model(**inputs, labels=inputs["input_ids"])
                loss = outputs.loss
                
                total_loss += loss.item() * inputs["input_ids"].size(1)
                total_tokens += inputs["input_ids"].size(1)
        
        avg_loss = total_loss / total_tokens
        perplexity = torch.exp(torch.tensor(avg_loss)).item()
        
        return perplexity
    
    def evaluate_model(self, model, tokenizer, test_data: Dict) -> Dict:
        """综合评估模型"""
        results = {}
        
        # 文本生成任务评估
        if "generation" in test_data:
            references = test_data["generation"]["references"]
            candidates = test_data["generation"]["candidates"]
            
            results["bleu"] = self.calculate_bleu(references, candidates)
            results["rouge"] = self.calculate_rouge(references, candidates)
        
        # 语言模型评估
        if "lm" in test_data:
            texts = test_data["lm"]["texts"]
            results["perplexity"] = self.calculate_perplexity(model, tokenizer, texts)
        
        # 分类任务评估
        if "classification" in test_data:
            from sklearn.metrics import accuracy_score, f1_score
            
            y_true = test_data["classification"]["true_labels"]
            y_pred = test_data["classification"]["pred_labels"]
            
            results["accuracy"] = accuracy_score(y_true, y_pred)
            results["f1_score"] = f1_score(y_true, y_pred, average="weighted")
        
        return results

# 使用示例
evaluator = NLPEvaluator()

test_data = {
    "generation": {
        "references": [
            "自然语言处理是人工智能的重要分支",
            "Transformer模型改变了NLP的发展方向"
        ],
        "candidates": [
            "NLP是AI的关键领域之一",
            "Transformer架构革新了NLP领域"
        ]
    },
    "lm": {
        "texts": [
            "深度学习在自然语言处理中应用广泛",
            "预训练模型提升了NLP任务的性能"
        ]
    }
}

# 这里需要实际的模型和tokenizer
# results = evaluator.evaluate_model(model, tokenizer, test_data)
print("评估系统准备就绪")

class NLPOptimizer:
    def __init__(self, model, tokenizer):
        self.model = model
        self.tokenizer = tokenizer
        self.optimization_history = []
    
    def prune_model(self, pruning_rate: float = 0.3):
        """模型剪枝"""
        import torch.nn.utils.prune as prune
        
        # 对线性层进行剪枝
        for name, module in self.model.named_modules():
            if isinstance(module, torch.nn.Linear):
                prune.l1_unstructured(module, name='weight', amount=pruning_rate)
                prune.remove(module, 'weight')
        
        self.optimization_history.append({
            "technique": "pruning",
            "rate": pruning_rate,
            "timestamp": datetime.now().isoformat()
        })
    
    def quantize_model(self, quantization_bits: int = 8):
        """模型量化"""
        if quantization_bits == 8:
            quantized_model = torch.quantization.quantize_dynamic(
                self.model,
                {torch.nn.Linear},
                dtype=torch.qint8
            )
            self.model = quantized_model
        
        self.optimization_history.append({
            "technique": "quantization",
            "bits": quantization_bits,
            "timestamp": datetime.now().isoformat()
        })
    
    def distill_model(self, teacher_model, temperature: float = 2.0):
        """知识蒸馏"""
        class DistillationLoss(nn.Module):
            def __init__(self, temperature):
                super().__init__()
                self.temperature = temperature
                self.kl_loss = nn.KLDivLoss(reduction='batchmean')
            
            def forward(self, student_logits, teacher_logits, labels):
                # 知识蒸馏损失
                student_log_softmax = F.log_softmax(student_logits / self.temperature, dim=-1)
                teacher_softmax = F.softmax(teacher_logits / self.temperature, dim=-1)
                kd_loss = self.kl_loss(student_log_softmax, teacher_softmax) * (self.temperature ** 2)
                
                # 学生模型的标准损失
                ce_loss = F.cross_entropy(student_logits, labels)
                
                # 组合损失
                return 0.7 * kd_loss + 0.3 * ce_loss
        
        self.optimization_history.append({
            "technique": "distillation",
            "temperature": temperature,
            "timestamp": datetime.now().isoformat()
        })
        
        return DistillationLoss(temperature)
    
    def optimize_inference(self, batch_size: int = 32, use_jit: bool = True):
        """推理优化"""
        optimization_config = {
            "batch_size": batch_size,
            "use_jit": use_jit,
            "half_precision": True,
            "cache_attention": True
        }
        
        if use_jit:
            # 使用TorchScript优化
            self.model = torch.jit.script(self.model)
        
        self.optimization_history.append({
            "technique": "inference_optimization",
            "config": optimization_config,
            "timestamp": datetime.now().isoformat()
        })
        
        return optimization_config
    
    def get_optimization_report(self) -> str:
        """生成优化报告"""
        report = "NLP模型优化报告\n"
        report += "=" * 50 + "\n\n"
        
        for record in self.optimization_history:
            report += f"技术: {record['technique']}\n"
            report += f"时间: {record['timestamp']}\n"
            
            if 'rate' in record:
                report += f"剪枝率: {record['rate']*100}%\n"
            elif 'bits' in record:
                report += f"量化位数: {record['bits']}位\n"
            elif 'temperature' in record:
                report += f"蒸馏温度: {record['temperature']}\n"
            elif 'config' in record:
                report += f"配置: {record['config']}\n"
            
            report += "-" * 30 + "\n"
        
        return report

# 使用示例
print("NLP优化工具准备就绪")

class NLPResearchAgenda:
    def __init__(self):
        self.research_areas = {
            "基础研究": [
                "更高效的注意力机制",
                "新型神经网络架构",
                "无监督学习算法",
                "小样本学习技术"
            ],
            "应用研究": [
                "医疗NLP应用",
                "法律文本分析",
                "教育智能助手",
                "金融风险分析"
            ],
            "伦理与社会": [
                "AI公平性研究",
                "偏见检测与消除",
                "可解释NLP",
                "AI治理框架"
            ],
            "工程优化": [
                "模型压缩技术",
                "分布式训练优化",
                "边缘设备部署",
                "实时推理加速"
            ]
        }
    
    def prioritize_topics(self, criteria: Dict) -> List[str]:
        """根据标准优先排序研究主题"""
        prioritized = []
        
        for area, topics in self.research_areas.items():
            for topic in topics:
                score = 0
                
                # 根据影响因子评分
                if criteria.get("impact", False):
                    if "基础" in area or "架构" in topic:
                        score += 3
                    elif "应用" in area:
                        score += 2
                
                # 根据可行性评分
                if criteria.get("feasibility", False):
                    if "优化" in area or "工程" in topic:
                        score += 2
                    elif "伦理" in area:
                        score += 1
                
                # 根据资源需求评分
                if criteria.get("resource_efficient", False):
                    if "高效" in topic or "压缩" in topic:
                        score += 2
                    elif "大模型" in topic:
                        score -= 1
                
                prioritized.append((topic, score, area))
        
        # 按分数排序
        prioritized.sort(key=lambda x: -x[1])
        return prioritized[:10]  # 返回前10个主题

# 使用示例
research = NLPResearchAgenda()
criteria = {
    "impact": True,
    "feasibility": True,
    "resource_efficient": True
}

print("🔬 优先研究主题：")
for i, (topic, score, area) in enumerate(research.prioritize_topics(criteria), 1):
    print(f"{i}. {topic} ({area}) - 优先级: {score}分")