问题：谁创办了苹果公司？
上下文：苹果公司由史蒂夫·乔布斯、斯蒂夫·沃兹尼亚克和罗纳德·韦恩于1976年4月1日创立。
答案：史蒂夫·乔布斯、斯蒂夫·沃兹尼亚克和罗纳德·韦恩

[CLS] 问题 [SEP] 上下文 [SEP]

from transformers import BertForQuestionAnswering, BertTokenizer
import torch

tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
model = BertForQuestionAnswering.from_pretrained("bert-base-uncased")

question = "Who founded Apple Inc.?"
context = "Apple Inc. was founded by Steve Jobs, Steve Wozniak, and Ronald Wayne on April 1, 1976."

inputs = tokenizer(question, context, return_tensors="pt", max_length=512, truncation=True)

with torch.no_grad():
    outputs = model(**inputs)
    start_logits = outputs.start_logits
    end_logits = outputs.end_logits

start_idx = torch.argmax(start_logits, dim=-1)
end_idx = torch.argmax(end_logits, dim=-1)

answer = tokenizer.decode(inputs["input_ids"][0][start_idx:end_idx+1])
print(f"Answer: {answer}")

class BertQA(nn.Module):
    def __init__(self, pretrained_model_name="bert-base-uncased"):
        super().__init__()
        self.bert = AutoModel.from_pretrained(pretrained_model_name)
        self.qa_outputs = nn.Linear(self.bert.config.hidden_size, 2)  # start, end

    def forward(self, input_ids, attention_mask, token_type_ids):
        outputs = self.bert(input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids)
        sequence_output = outputs.last_hidden_state
        logits = self.qa_outputs(sequence_output)
        start_logits, end_logits = logits.split(1, dim=-1)
        return start_logits.squeeze(-1), end_logits.squeeze(-1)

def compute_loss(start_logits, end_logits, start_positions, end_positions):
    loss_fn = nn.CrossEntropyLoss()
    start_loss = loss_fn(start_logits, start_positions)
    end_loss = loss_fn(end_logits, end_positions)
    return (start_loss + end_loss) / 2

# 简化的开放域 QA 流程
class OpenDomainQA:
    def __init__(self, retriever, reader):
        self.retriever = retriever
        self.reader = reader

    def answer(self, question, top_k=5):
        # 1. 检索相关文档
        documents = self.retriever.search(question, top_k=top_k)

        # 2. 从每个文档中提取答案
        answers = []
        for doc in documents:
            answer = self.reader.extract_answer(question, doc)
            answers.append(answer)

        # 3. 选择最佳答案
        best_answer = self.select_best(answers)
        return best_answer

from transformers import DPRQuestionEncoder, DPRContextEncoder, DPRTokenizer

question_encoder = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
context_encoder = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")
tokenizer = DPRTokenizer.from_pretrained("facebook/dpr-question_encoder-single-nq-base")

# 编码问题
question = "Who founded Apple?"
q_inputs = tokenizer(question, return_tensors="pt")
q_embedding = question_encoder(**q_inputs).pooler_output

# 编码文档并计算相似度
documents = ["Apple was founded by Steve Jobs.", "Google was founded by Larry Page."]
d_inputs = tokenizer(documents, return_tensors="pt", padding=True)
d_embeddings = context_encoder(**d_inputs).pooler_output

# 计算相似度
similarities = torch.mm(q_embedding, d_embeddings.T)
print(similarities)

用户问题 → 检索器 → 相关文档 → 生成器（LLM + 检索结果）→ 答案

from transformers import RagTokenizer, RagRetriever, RagSequenceForGeneration

tokenizer = RagTokenizer.from_pretrained("facebook/rag-sequence-nq")
retriever = RagRetriever.from_pretrained("facebook/rag-sequence-nq", index_name="legacy")
model = RagSequenceForGeneration.from_pretrained("facebook/rag-sequence-nq", retriever=retriever)

question = "Who founded Apple Inc.?"
inputs = tokenizer(question, return_tensors="pt")
generated = model.generate(inputs["input_ids"])
answer = tokenizer.batch_decode(generated, skip_special_tokens=True)
print(f"Answer: {answer}")

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA

# 构建向量数据库
documents = [
    "Apple Inc. was founded on April 1, 1976 by Steve Jobs, Steve Wozniak, and Ronald Wayne.",
    "The company is headquartered in Cupertino, California.",
    "Tim Cook has been CEO since 2011.",
]
vectorstore = FAISS.from_texts(documents, OpenAIEmbeddings())

# 构建 QA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    retriever=vectorstore.as_retriever(),
    chain_type="stuff",
)

# 问答
result = qa_chain.run("Who founded Apple?")
print(result)

知识图谱：(Steve Jobs, founder_of, Apple Inc.)
问题：谁创办了苹果公司？
答案：Steve Jobs

def compute_f1(prediction, ground_truth):
    pred_tokens = set(prediction.lower().split())
    gt_tokens = set(ground_truth.lower().split())

    if len(pred_tokens) == 0 or len(gt_tokens) == 0:
        return float(pred_tokens == gt_tokens)

    common = pred_tokens & gt_tokens
    precision = len(common) / len(pred_tokens)
    recall = len(common) / len(gt_tokens)
    f1 = 2 * precision * recall / (precision + recall)
    return f1

# 示例
print(compute_f1("Steve Jobs", "Steve Jobs"))  # 1.0
print(compute_f1("Steve Jobs and Wozniak", "Steve Jobs"))  # 0.667

from transformers import pipeline

qa_pipeline = pipeline("question-answering", model="deepset/roberta-base-squad2")

context = """
Albert Einstein was a German-born theoretical physicist.
He developed the theory of relativity. His mass-energy equivalence
formula E = mc² is one of the most famous equations in physics.
He was awarded the Nobel Prize in Physics in 1921.
"""

result = qa_pipeline(
    question="When did Einstein receive the Nobel Prize?",
    context=context,
)
print(f"Answer: {result['answer']}")
print(f"Score: {result['score']:.4f}")

import numpy as np
from sentence_transformers import SentenceTransformer

class SimpleRAG:
    def __init__(self, documents, model_name="all-MiniLM-L6-v2"):
        self.model = SentenceTransformer(model_name)
        self.documents = documents
        self.embeddings = self.model.encode(documents)

    def retrieve(self, query, top_k=3):
        query_embedding = self.model.encode(query)
        similarities = np.dot(self.embeddings, query_embedding)
        top_indices = similarities.argsort()[-top_k:][::-1]
        return [(self.documents[i], similarities[i]) for i in top_indices]

    def answer(self, query):
        retrieved = self.retrieve(query)
        context = "\n".join([doc for doc, _ in retrieved])
        prompt = f"""Based on the following context, answer the question.

Context: {context}
Question: {query}
Answer:"""
        return prompt  # 实际应用中会调用 LLM 生成答案

# 使用
documents = [
    "Python was created by Guido van Rossum and first released in 1991.",
    "Python is known for its simple and readable syntax.",
    "Python supports multiple programming paradigms including OOP and functional programming.",
    "Popular Python frameworks include Django, Flask, and FastAPI.",
]
rag = SimpleRAG(documents)
print(rag.answer("Who created Python?"))

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch

# 加载 SQuAD 数据集
dataset = load_dataset("squad")
tokenizer = AutoTokenizer.from_pretrained("deepset/roberta-base-squad2")
model = AutoModelForQuestionAnswering.from_pretrained("deepset/roberta-base-squad2")

# 评估前 100 个样本
correct = 0
total = 0

for example in dataset["validation"].select(range(100)):
    question = example["question"]
    context = example["context"]
    ground_truth = example["answers"]["text"][0]

    inputs = tokenizer(question, context, return_tensors="pt", max_length=512, truncation=True)
    with torch.no_grad():
        outputs = model(**inputs)

    start_idx = torch.argmax(outputs.start_logits, dim=-1)
    end_idx = torch.argmax(outputs.end_logits, dim=-1)
    answer = tokenizer.decode(inputs["input_ids"][0][start_idx:end_idx+1])

    if answer.strip().lower() == ground_truth.strip().lower():
        correct += 1
    total += 1

print(f"Exact Match: {correct/total:.4f}")