大模型应用：搜索的智能革命：大模型如何重塑传统搜索算法构建新一代智能检索.110

# 测试文档集
documents = [
    {
        "id": 1,
        "content": "大语言模型（LLM）在搜索领域的应用主要体现在语义理解和向量召回。通过将文本转化为Embedding向量，大模型能突破传统关键词匹配的局限，找到语义相关的文档。比如用户搜索‘AI如何提升搜索效率’，大模型能理解核心需求是‘人工智能对搜索算法的优化’，而非仅匹配关键词。"
    },
    {
        "id": 2,
        "content": "向量数据库是大模型搜索的核心组件之一。FAISS是Facebook开源的向量数据库，支持高效的向量相似度检索，能处理百万级甚至亿级的向量数据。与传统数据库不同，向量数据库的核心索引算法如HNSW，能大幅提升向量检索的速度，满足实时搜索的需求。"
    },
    {
        "id": 3,
        "content": "传统搜索算法的核心是倒排索引和BM25排序。倒排索引负责快速召回包含关键词的文档，BM25则通过词频和逆文档频率计算相关性得分。但传统算法无法处理语义差异，比如‘猫咪拆家’和‘猫主子破坏家具’会被判定为不相关，这也是大模型需要补充的环节。"
    },
    {
        "id": 4,
        "content": "大模型重排是提升搜索精准度的关键步骤。在召回阶段得到候选文档后，使用BERT类模型计算‘搜索词-文档’的语义相似度，再结合BM25得分进行加权排序，能让排序结果更符合用户的语义需求。重排模型通常选择轻量级版本，以保证推理速度。"
    },
    {
        "id": 5,
        "content": "大模型生成能力能优化搜索结果展示。将排序后的文档内容输入ChatGLM等开源大模型，通过合理的提示词设计，让模型总结出简洁的答案，而非让用户逐个阅读文档。这一过程需要控制模型的幻觉问题，确保答案基于文档内容，不编造信息。"
    }
]

import jieba
import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# 1. 加载Embedding模型（中文优化版）
model = SentenceTransformer("D:\\modelscope\\hub\\sentence-transformers\\paraphrase-multilingual-MiniLM-L12-v2")

# 2. 文档预处理函数：分词、去停用词
def preprocess_text(text):
    # 停用词列表（基础版）
    stop_words = {'的', '了', '是', '在', '有', '能', '都', '就', '及', '与', '对', '为'}
    # 分词
    words = jieba.lcut(text)
    # 去停用词和空字符
    filtered_words = [word for word in words if word not in stop_words and word.strip() != '']
    # 拼接为字符串（用于Embedding生成）
    return ' '.join(filtered_words)

# 3. 为每个文档生成Embedding
document_embeddings = []
processed_documents = []
for doc in documents:
    # 预处理文档内容
    processed_content = preprocess_text(doc['content'])
    processed_documents.append({
        'id': doc['id'],
        'content': doc['content'],
        'processed_content': processed_content
    })
    # 生成Embedding向量（shape: (1, 1024)）
    embedding = model.encode(processed_content)
    document_embeddings.append(embedding)

# 转换为numpy数组，方便后续计算（shape: (5, 1024)）
document_embeddings = np.vstack(document_embeddings)

# 构建倒排索引：key=关键词，value=文档ID列表
inverted_index = {}
for doc in processed_documents:
    doc_id = doc['id']
    # 拆分预处理后的关键词
    keywords = doc['processed_content'].split()
    for keyword in keywords:
        if keyword not in inverted_index:
            inverted_index[keyword] = []
        if doc_id not in inverted_index[keyword]:
            inverted_index[keyword].append(doc_id)

# 倒排索引召回函数
def inverted_index_retrieval(query, inverted_index, processed_documents):
    # 预处理查询词
    processed_query = preprocess_text(query)
    query_keywords = processed_query.split()
    # 收集包含任意关键词的文档ID
    candidate_doc_ids = set()
    for keyword in query_keywords:
        if keyword in inverted_index:
            candidate_doc_ids.update(inverted_index[keyword])
    # 返回候选文档
    candidate_docs = [doc for doc in processed_documents if doc['id'] in candidate_doc_ids]
    return candidate_docs

# 向量召回函数
def vector_retrieval(query, model, document_embeddings, processed_documents, top_k=3):
    # 预处理并生成查询词Embedding
    processed_query = preprocess_text(query)
    query_embedding = model.encode(processed_query).reshape(1, -1)
    # 计算余弦相似度
    similarities = cosine_similarity(query_embedding, document_embeddings)[0]
    # 按相似度排序，取Top K
    top_indices = similarities.argsort()[::-1][:top_k]
    # 返回Top K文档
    top_docs = [processed_documents[i] for i in top_indices]
    return top_docs

# 混合召回函数：合并倒排索引和向量召回结果，去重
def hybrid_retrieval(query, inverted_index, model, document_embeddings, processed_documents):
    # 倒排索引召回
    inverted_docs = inverted_index_retrieval(query, inverted_index, processed_documents)
    # 向量召回
    vector_docs = vector_retrieval(query, model, document_embeddings, processed_documents)
    # 合并结果，按文档ID去重
    doc_id_set = set()
    hybrid_docs = []
    # 先加向量召回的结果（优先级更高）
    for doc in vector_docs:
        if doc['id'] not in doc_id_set:
            doc_id_set.add(doc['id'])
            hybrid_docs.append(doc)
    # 再加倒排索引召回的结果（补充）
    for doc in inverted_docs:
        if doc['id'] not in doc_id_set:
            doc_id_set.add(doc['id'])
            hybrid_docs.append(doc)
    return hybrid_docs

# 简化版重排：基于语义相似度排序
def rerank_docs(query, docs, model):
    # 生成查询词Embedding
    processed_query = preprocess_text(query)
    query_embedding = model.encode(processed_query).reshape(1, -1)
    # 计算每个文档与查询词的相似度
    doc_scores = []
    for doc in docs:
        doc_embedding = model.encode(doc['processed_content']).reshape(1, -1)
        similarity = cosine_similarity(query_embedding, doc_embedding)[0][0]
        doc_scores.append({
            'id': doc['id'],
            'content': doc['content'],
            'similarity': similarity
        })
    # 按相似度从高到低排序
    reranked_docs = sorted(doc_scores, key=lambda x: x['similarity'], reverse=True)
    return reranked_docs

from modelscope import AutoModelForCausalLM, AutoTokenizer

# 加载Qwen1.5-0.5B-Chat本地模型（使用完整路径）
model_path = "D:\\modelscope\\hub\\models\\qwen\\Qwen1___5-0___5B-Chat"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model_chat = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True)

# 答案生成函数
def generate_answer(query, reranked_docs):
    # 拼接文档内容
    doc_content = ""
    for i, doc in enumerate(reranked_docs[:3]):  # 取前3篇最相关的文档
        doc_content += f"文档{i+1}：{doc['content']}\n"
    
    # 构建Prompt（使用Qwen的聊天格式）
    messages = [
        {"role": "system", "content": "你是一个专业的搜索助手，请基于给定的文档内容回答用户问题。"},
        {"role": "user", "content": f"请基于以下文档内容，回答用户的问题：{query}\n\n文档内容：\n{doc_content}\n\n要求：\n1. 答案必须基于上述文档内容，不得添加无关信息；\n2. 语言简洁易懂，分点说明；\n3. 标注信息来源（文档编号）。"}
    ]
    
    # 调用大模型生成答案
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = tokenizer(text, return_tensors="pt")
    outputs = model_chat.generate(**inputs, max_new_tokens=512)
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response

# 主函数：完整搜索流程
def semantic_search(query):
    print(f"用户搜索词：{query}")
    print("="*50)
    
    # 1. 混合召回
    hybrid_docs = hybrid_retrieval(query, inverted_index, model, document_embeddings, processed_documents)
    print(f"混合召回文档数：{len(hybrid_docs)}")
    
    # 2. 大模型重排
    reranked_docs = rerank_docs(query, hybrid_docs, model)
    print("重排后前3篇文档相似度：")
    for doc in reranked_docs[:3]:
        print(f"文档ID：{doc['id']}，相似度：{doc['similarity']:.4f}")
    print("="*50)
    
    # 3. 生成答案
    answer = generate_answer(query, reranked_docs)
    print("大模型生成的答案：")
    print(answer)

# 测试搜索
if __name__ == "__main__":
    # 用户输入搜索词
    user_query = "大模型如何提升搜索算法的效果"
    # 执行搜索
    semantic_search(user_query)

import jieba
import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# 1. 加载Embedding模型（中文优化版）
model = SentenceTransformer("D:\\modelscope\\hub\\sentence-transformers\\paraphrase-multilingual-MiniLM-L12-v2")

# 测试文档集
documents = [
    {
        "id": 1,
        "content": "大语言模型（LLM）在搜索领域的应用主要体现在语义理解和向量召回。通过将文本转化为Embedding向量，大模型能突破传统关键词匹配的局限，找到语义相关的文档。比如用户搜索‘AI如何提升搜索效率’，大模型能理解核心需求是‘人工智能对搜索算法的优化’，而非仅匹配关键词。"
    },
    {
        "id": 2,
        "content": "向量数据库是大模型搜索的核心组件之一。FAISS是Facebook开源的向量数据库，支持高效的向量相似度检索，能处理百万级甚至亿级的向量数据。与传统数据库不同，向量数据库的核心索引算法如HNSW，能大幅提升向量检索的速度，满足实时搜索的需求。"
    },
    {
        "id": 3,
        "content": "传统搜索算法的核心是倒排索引和BM25排序。倒排索引负责快速召回包含关键词的文档，BM25则通过词频和逆文档频率计算相关性得分。但传统算法无法处理语义差异，比如‘猫咪拆家’和‘猫主子破坏家具’会被判定为不相关，这也是大模型需要补充的环节。"
    },
    {
        "id": 4,
        "content": "大模型重排是提升搜索精准度的关键步骤。在召回阶段得到候选文档后，使用BERT类模型计算‘搜索词-文档’的语义相似度，再结合BM25得分进行加权排序，能让排序结果更符合用户的语义需求。重排模型通常选择轻量级版本，以保证推理速度。"
    },
    {
        "id": 5,
        "content": "大模型生成能力能优化搜索结果展示。将排序后的文档内容输入ChatGLM等开源大模型，通过合理的提示词设计，让模型总结出简洁的答案，而非让用户逐个阅读文档。这一过程需要控制模型的幻觉问题，确保答案基于文档内容，不编造信息。"
    }
]

# 2. 文档预处理函数：分词、去停用词
def preprocess_text(text):
    # 停用词列表（基础版）
    stop_words = {'的', '了', '是', '在', '有', '能', '都', '就', '及', '与', '对', '为'}
    # 分词
    words = jieba.lcut(text)
    # 去停用词和空字符
    filtered_words = [word for word in words if word not in stop_words and word.strip() != '']
    # 拼接为字符串（用于Embedding生成）
    return ' '.join(filtered_words)

# 3. 为每个文档生成Embedding
document_embeddings = []
processed_documents = []
for doc in documents:
    # 预处理文档内容
    processed_content = preprocess_text(doc['content'])
    processed_documents.append({
        'id': doc['id'],
        'content': doc['content'],
        'processed_content': processed_content
    })
    # 生成Embedding向量（shape: (1, 1024)）
    embedding = model.encode(processed_content)
    document_embeddings.append(embedding)

# 转换为numpy数组，方便后续计算（shape: (5, 1024)）
document_embeddings = np.vstack(document_embeddings)

# 构建倒排索引：key=关键词，value=文档ID列表
inverted_index = {}
for doc in processed_documents:
    doc_id = doc['id']
    # 拆分预处理后的关键词
    keywords = doc['processed_content'].split()
    for keyword in keywords:
        if keyword not in inverted_index:
            inverted_index[keyword] = []
        if doc_id not in inverted_index[keyword]:
            inverted_index[keyword].append(doc_id)

# 倒排索引召回函数
def inverted_index_retrieval(query, inverted_index, processed_documents):
    # 预处理查询词
    processed_query = preprocess_text(query)
    query_keywords = processed_query.split()
    # 收集包含任意关键词的文档ID
    candidate_doc_ids = set()
    for keyword in query_keywords:
        if keyword in inverted_index:
            candidate_doc_ids.update(inverted_index[keyword])
    # 返回候选文档
    candidate_docs = [doc for doc in processed_documents if doc['id'] in candidate_doc_ids]
    return candidate_docs

# 向量召回函数
def vector_retrieval(query, model, document_embeddings, processed_documents, top_k=3):
    # 预处理并生成查询词Embedding
    processed_query = preprocess_text(query)
    query_embedding = model.encode(processed_query).reshape(1, -1)
    # 计算余弦相似度
    similarities = cosine_similarity(query_embedding, document_embeddings)[0]
    # 按相似度排序，取Top K
    top_indices = similarities.argsort()[::-1][:top_k]
    # 返回Top K文档
    top_docs = [processed_documents[i] for i in top_indices]
    return top_docs

# 混合召回函数：合并倒排索引和向量召回结果，去重
def hybrid_retrieval(query, inverted_index, model, document_embeddings, processed_documents):
    # 倒排索引召回
    inverted_docs = inverted_index_retrieval(query, inverted_index, processed_documents)
    # 向量召回
    vector_docs = vector_retrieval(query, model, document_embeddings, processed_documents)
    # 合并结果，按文档ID去重
    doc_id_set = set()
    hybrid_docs = []
    # 先加向量召回的结果（优先级更高）
    for doc in vector_docs:
        if doc['id'] not in doc_id_set:
            doc_id_set.add(doc['id'])
            hybrid_docs.append(doc)
    # 再加倒排索引召回的结果（补充）
    for doc in inverted_docs:
        if doc['id'] not in doc_id_set:
            doc_id_set.add(doc['id'])
            hybrid_docs.append(doc)
    return hybrid_docs

# 简化版重排：基于语义相似度排序
def rerank_docs(query, docs, model):
    # 生成查询词Embedding
    processed_query = preprocess_text(query)
    query_embedding = model.encode(processed_query).reshape(1, -1)
    # 计算每个文档与查询词的相似度
    doc_scores = []
    for doc in docs:
        doc_embedding = model.encode(doc['processed_content']).reshape(1, -1)
        similarity = cosine_similarity(query_embedding, doc_embedding)[0][0]
        doc_scores.append({
            'id': doc['id'],
            'content': doc['content'],
            'similarity': similarity
        })
    # 按相似度从高到低排序
    reranked_docs = sorted(doc_scores, key=lambda x: x['similarity'], reverse=True)
    return reranked_docs

from modelscope import AutoModelForCausalLM, AutoTokenizer

# 加载Qwen1.5-0.5B-Chat本地模型（使用完整路径）
model_path = "D:\\modelscope\\hub\\models\\qwen\\Qwen1___5-0___5B-Chat"
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model_chat = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True)

# 答案生成函数
def generate_answer(query, reranked_docs):
    # 拼接文档内容
    doc_content = ""
    for i, doc in enumerate(reranked_docs[:3]):  # 取前3篇最相关的文档
        doc_content += f"文档{i+1}：{doc['content']}\n"
    
    # 构建Prompt（使用Qwen的聊天格式）
    messages = [
        {"role": "system", "content": "你是一个专业的搜索助手，请基于给定的文档内容回答用户问题。"},
        {"role": "user", "content": f"请基于以下文档内容，回答用户的问题：{query}\n\n文档内容：\n{doc_content}\n\n要求：\n1. 答案必须基于上述文档内容，不得添加无关信息；\n2. 语言简洁易懂，分点说明；\n3. 标注信息来源（文档编号）。"}
    ]
    
    # 调用大模型生成答案
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = tokenizer(text, return_tensors="pt")
    outputs = model_chat.generate(**inputs, max_new_tokens=512)
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response

# 主函数：完整搜索流程
def semantic_search(query):
    print(f"用户搜索词：{query}")
    print("="*50)
    
    # 1. 混合召回
    hybrid_docs = hybrid_retrieval(query, inverted_index, model, document_embeddings, processed_documents)
    print(f"混合召回文档数：{len(hybrid_docs)}")
    
    # 2. 大模型重排
    reranked_docs = rerank_docs(query, hybrid_docs, model)
    print("重排后前3篇文档相似度：")
    for doc in reranked_docs[:3]:
        print(f"文档ID：{doc['id']}，相似度：{doc['similarity']:.4f}")
    print("="*50)
    
    # 3. 生成答案
    answer = generate_answer(query, reranked_docs)
    print("大模型生成的答案：")
    print(answer)

# 测试搜索
if __name__ == "__main__":
    # 用户输入搜索词
    user_query = "大模型如何提升搜索算法的效果"
    # 执行搜索
    semantic_search(user_query)