# AIGC应用 ## 深度学习#向量数据库知识问答前期操作：文档切割/文档向量/chatgpt + langchain| NLTK | BERT | text2vect |

向日葵花籽儿

已于 2024-02-01 14:12:48 修改

阅读量1.1k

点赞数 20

分类专栏：深度学习 AIGC NLP 文章标签：深度学习 AIGC langchain 人工智能 NLTK BERT text2vect

于 2024-01-22 15:00:42 首次发布

本文链接：https://blog.csdn.net/weixin_45312236/article/details/135704297

版权

AIGC 同时被 3 个专栏收录

22 篇文章 0 订阅

订阅专栏

NLP

13 篇文章 0 订阅

订阅专栏

深度学习

8 篇文章 0 订阅

订阅专栏

本文所用的技术仓库：
https://github.com/langchain-ai/langchain
https://github.com/nltk/nltk https://github.com/google-research/bert
https://github.com/shibing624/text2vec

本文是利用chatgpt + langchain| NLTK | BERT | text2vect |四种文档切割的效果测试研究，附上源码可以自己实践

大模型切割-chatgpt+langchain

langchain 介绍

LangChain 是一个应用框架，旨在简化使用大型语言模型（LLM）的应用程序。作为一个语言模型集成框架，LangChain 的用例与一般语言模型的用例有很大的重叠。重叠范围包括文档分析和总结摘要、代码分析和聊天机器人。LangChain提供了一个标准接口，用于将不同的语言模型连接在一起，以及与其他工具和数据源的集成。

LangChain 的核心功能包括：

**语言模型集成：**LangChain 提供了一个标准接口，用于将不同的语言模型连接在一起。这使得开发人员可以轻松地将不同的语言模型用于自己的应用程序。
**数据源集成：**LangChain 提供了与各种数据源的集成，例如文本、代码和图像。这使得开发人员可以使用 LangChain 来处理各种类型的数据。
**应用开发：**LangChain 提供了一些预先构建的应用程序，例如文档分析、代码分析和聊天机器人。开发人员可以使用这些应用程序作为起点，并根据自己的需求进行定制。

LangChain 的优势包括：

**易于使用：**LangChain 提供了一个简单的 API，使得开发人员可以轻松地将 LangChain 用于自己的应用程序。
**灵活性：**LangChain 提供了各种功能，使得开发人员可以满足各种需求。
**可扩展性：**LangChain 可以扩展到处理大量数据和复杂的应用程序。

LangChain 的缺点包括：

**依赖大型语言模型：**LangChain 需要大型语言模型才能发挥其全部功能。
**性能：**LangChain 的性能可能受到大型语言模型的大小和复杂性的影响。

总体而言，LangChain 是一个强大的工具，可以帮助开发人员使用大型语言模型来构建各种应用程序。

提示词：

> 提示词：
【需要拆分的文本：】
    {{init_text}}
    1. 拆分要求：你需要对上面的待拆分的文本进行拆分，并且遵顼下面的具体拆分要求
    2. 拆分方式： 根据实体（时间、地点、人物）或主题进行拆分。
    3. 实体识别： 确定文本中涉及的时间、地点、人物等实体，并提供相关信息。
    4. 主题识别： 澄清文本中的主题，以便更好地进行拆分。
    5. 拆分格式：
    序号：
    主题：
    实体：
    原文：(必须是切块后原文内容)
    6.. 拆分示例：只是一个教你拆分的示例
    拆分结果：
    序号：1
    主题：社会能的分类
    实体：社会能、人类、工具、环境
    原文：社会能，大致可以分为三类，一类是人生长发育以及日常生活所需要消耗的能量，二是人制造的工具运转需要消耗的能量，三是人类，所处环境所消耗的能量。
    序号：2
    主题：能量经济学研究范围
    实体：能量经济学、人类、影响、能力转换
    原文：一般情况下，人类所处环境所消耗的能量，不是人类能控制得，至少以目前人类社会的现状来看。人类生活的环境，所消耗的能量，受人类影响是很少的。能量经济学，暂时不研究这一块能量的转化。
    而人类自身生存所需要的能量和工具或者机器所消耗的能量，都与人类自身多多少少有关系。所以能量经济学，目前只研究，这两类能量的转化与流动。

连接chatgpt


def GPT_API(api_key, message, model, count=0):
    url = "https://api.openai.com/v1/chat/completions"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    data = {
        "model": model,
        "messages": [{"role": "user", "content": message}],
        "temperature": 0.7,
    }
    response = requests.post(url, headers=headers, data=json.dumps(data))
    topic = response.json()
    try:
        content = topic['choices'][0]["message"]["content"]
    except:
        if count != 3:
            count = count + 1
            content = GPT_API(api_key, message, model, count)
        else:
            content = ""
    print(content)
    return content

全部代码

from docx import Document
from core.xr.spiltter.chinese_recursive_text_splitter import ChineseRecursiveTextSplitter
from langchain.schema import BaseMessage, SystemMessage
from tqdm import tqdm
import time

import json
import requests

def read_docx(docx_path):
    doc = Document(docx_path)
    text = ""
    for paragraph in doc.paragraphs:
        if paragraph.text == "" and text != "":
            text = text + "\n"
        text = text + paragraph.text
    return text


def split_text(ls_text):
	# 这里可以自己写分段函数，我调用的是4090token的3.5接口，就设置分段长度最大1000字，重叠部分100字
    text_splitter = ChineseRecursiveTextSplitter(
        keep_separator=True,
        is_separator_regex=True,
        chunk_size=1000,
        chunk_overlap=100
    )
    ls = [
        ls_text
    ]
    chunks = None
    # text = """"""
    for inum, text in enumerate(ls):
        chunks = text_splitter.split_text(text)
    return chunks


def GPT_API(api_key, message, model, count=0):
    url = "https://api.openai.com/v1/chat/completions"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    data = {
        "model": model,
        "messages": [{"role": "user", "content": message}],
        "temperature": 0.7,
    }
    response = requests.post(url, headers=headers, data=json.dumps(data))
    topic = response.json()
    try:
        content = topic['choices'][0]["message"]["content"]
    except:
        if count != 3:
            count = count + 1
            content = GPT_API(api_key, message, model, count)
        else:
            content = ""
    print(content)
    return content


def gpt_split(init_text, model="gpt-3.5-turbo"):
    split_prompt = f"""【需要拆分的文本：】
    {init_text}
       1. 拆分要求：你需要对上面的待拆分的文本进行拆分，并且遵顼下面的具体拆分要求
    2. 拆分方式： 根据主题进行拆分。
    3. 主题识别： 澄清文本中的主题，以便更好地进行拆分。
    4. 拆分格式：
    序号：
    主题：
    原文：(必须是切块后原文内容)
    5.. 拆分示例：只是一个教你拆分的示例
    拆分结果：
    序号：1
    主题：社会能的分类
    原文：社会能，大致可以分为三类，一类是人生长发育以及日常生活所需要消耗的能量，二是人制造的工具运转需要消耗的能量，三是人类，所处环境所消耗的能量。
    序号：2
    主题：能量经济学研究范围
    原文：一般情况下，人类所处环境所消耗的能量，不是人类能控制得，至少以目前人类社会的现状来看。人类生活的环境，所消耗的能量，受人类影响是很少的。能量经济学，暂时不研究这一块能量的转化。
    而人类自身生存所需要的能量和工具或者机器所消耗的能量，都与人类自身多多少少有关系。所以能量经济学，目前只研究，这两类能量的转化与流动。"""

     content = GPT_API(你的api-key,split_prompt, model=model)
    # 按照换行符进行拆分
    result = content.split("\n")
    return content

def split_main():
    docx_path = "你的文档"
    text = read_docx(docx_path)
    chunks = split_text(text)
    contents = []
    data_result = ""
    for chunk in chunks:
        start_time = time.time()
        content = gpt_split(chunk)
        contents = contents + [content]
        data_result = data_result + content+"\n----------\n"
        with open("你的输出路径", "a", encoding="utf-8") as file:
            file.write(content + "\n")
        end_time = time.time()
        execution_time = end_time - start_time
        print("程序运行时间为：", execution_time, "秒")
split_main()

应用文档分割优点

chatgpt模型本身就是一个上下文预测模型，因此对于基于文意的拆分本就具有优势
在此基础上，我又设置提示词给了chatgpt思维链，让chatgpt有依据地去进行分段
效果很好，堪比人工分段
速度比人工快

应用文档分割缺点

由于接口访问速度原因，速度还是很慢

NLTK

介绍

NLTK 是一个用于处理人类语言数据的 Python 库。以下是 NLTK 的一些主要特点和功能：

文本处理： NLTK 提供了各种文本处理工具，包括分词、词性标注、命名实体识别、句法分析等。这些工具帮助用户处理和理解文本数据。

语料库： NLTK 包含丰富的语料库，涵盖了不同领域和主题的文本数据。这些语料库可用于训练和评估自然语言处理模型。

分析工具： NLTK 提供了各种分析工具，包括情感分析、文本分类、信息检索等。这些工具可以帮助用户从文本中提取有用的信息和洞察。

机器学习： NLTK 集成了一些机器学习算法，可用于构建自然语言处理模型。用户可以使用 NLTK 进行文本分类、文本聚类等任务。

教育和学术研究： NLTK 最初设计用于教育和学术研究，它提供了丰富的教程和资源，使用户能够学习和理解自然语言处理的基本概念和技术。

支持多语言： NLTK 支持多种语言，使其成为一个多语言的自然语言处理工具库。

开源社区： NLTK 是一个开源项目，拥有活跃的社区支持。用户可以参与贡献、提出问题和分享经验。

自身优缺点

NLTK（Natural Language Toolkit）作为一个自然语言处理工具库，具有一些优点和缺点。以下是 NLTK 的一些主要优缺点：

优点：

广泛的功能： NLTK 提供了丰富的功能，涵盖了从文本预处理到自然语言处理任务的各个方面，包括分词、词性标注、命名实体识别、句法分析、文本分类等。
教育和学术用途： NLTK 最初设计用于教育和学术研究，因此它提供了丰富的教程、文档和资源，适合学习自然语言处理的初学者。
多语言支持： NLTK 支持多种语言，使其成为一个多语言的自然语言处理工具库。
开源和活跃的社区： NLTK 是一个开源项目，拥有活跃的社区支持。用户可以参与贡献、提出问题和分享经验。
机器学习集成： NLTK 集成了一些基础的机器学习算法，方便用户构建自然语言处理模型。

缺点：

性能较慢： 由于 NLTK 是用 Python 编写的，一些 NLTK 中的操作可能相对较慢。对于大规模数据集和复杂任务，可能需要考虑性能更高的库。
不适用于大规模生产环境： NLTK 在设计上更适合教育和学术研究，对于大规模生产环境可能存在一些性能和效率上的挑战。
深度学习支持较弱： 相对于一些新兴的深度学习框架，NLTK 的深度学习支持相对较弱。在一些深度学习任务上，其他专门的库可能更合适。
API 设计较为老旧： NLTK 的一些 API 设计相对较为老旧，可能不如一些新兴库的设计灵活和现代化。

总体而言，NLTK 在学术研究和初学者学习方面具有强大的优势，但在生产环境中，特别是对于大规模和高性能要求的任务，可能需要考虑其他更现代的自然语言处理库。

代码

个人感觉效果不是特别好，分割的很粗
糙，有可以优化的地方可以讨论一下

import nltk
import nltk

nltk.download('punkt')

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

from splittest_0 import read_docx


# 文本预处理
def preprocess_text(text):
    # 分句
    sentences = nltk.sent_tokenize(text)
    # 分段
    paragraphs = [sentence.strip() for sentence in sentences if sentence.strip()]
    return paragraphs


# 主题识别（这里简单使用TF-IDF向量化）
def topic_identification(paragraphs):
    vectorizer = TfidfVectorizer()
    tfidf_matrix = vectorizer.fit_transform(paragraphs)
    return tfidf_matrix


# 计算相似度
def calculate_similarity(tfidf_matrix):
    return cosine_similarity(tfidf_matrix)


# 分割文档
def segment_document(paragraphs, similarity_matrix, threshold):
    segments = []
    current_segment = [paragraphs[0]]

    for i in range(1, len(paragraphs)):
        if similarity_matrix[0, i] < threshold:
            segments.append(current_segment)
            current_segment = [paragraphs[i]]
        else:
            current_segment.append(paragraphs[i])

    segments.append(current_segment)
    return segments


def split_main():
    # 示例用法
    docx_path = "你的文档"
    document = read_docx(docx_path)
    paragraphs = preprocess_text(document)
    tfidf_matrix = topic_identification(paragraphs)
    similarity_matrix = calculate_similarity(tfidf_matrix)
    threshold = 0.95  # 根据需要调整相似度阈值
    segments = segment_document(paragraphs, similarity_matrix, threshold)
    output = ""
    # 打印分割后的文档
    for i, segment in enumerate(segments):
        print(f"Segment {i + 1}:")
        print(" ".join(segment))
        output = output + segment[0] + "\n-----------------\n"
        # 将字符串内容写入文本文件
    with open("output.txt", "w", encoding="utf-8") as file:
        file.write(output)

应用文档分割优点

速度较快

应用文档分割缺点

分割粗糙，效果不是特别理想

BERT

介绍

BERT（Bidirectional Encoder Representations from Transformers）是一种由Google开发的预训练的自然语言处理模型，属于Transformer架构的一种。以下是BERT的一些关键特点和介绍：

双向编码（Bidirectional Encoding）： BERT 之所以称为双向编码，是因为它在处理文本时同时考虑了上下文的左右两个方向。这种双向编码的特性有助于模型更好地理解文本中的语境和关系。
Transformer 架构： BERT 基于Transformer模型架构，这是一种使用自注意力机制（Self-Attention Mechanism）来捕捉输入序列中不同位置之间关系的深度学习架构。Transformer已经在自然语言处理领域取得了显著的成功。
预训练和微调： BERT 是通过预训练来学习通用的语言表示，然后可以在不同的下游任务上进行微调。这种两阶段的训练方法使得 BERT 在不同领域和任务上都能够取得很好的性能。
大规模语料库： BERT 是在大规模语料库上进行训练的，这包括了大量的文本数据，使得它能够学到通用的语言表示。这种预训练模型的优势在于可以迁移到多种任务而不需要从零开始训练。
多层双向 Transformer 编码器： BERT 模型包含多个层的双向 Transformer 编码器，每个编码器都能够处理输入序列的不同层次的语义表示。
Masked Language Model（MLM）： BERT 在预训练阶段使用了一种被称为 Masked Language Model 的任务。在这个任务中，输入文本中的一些词会被随机地遮盖掉，模型需要预测这些被遮盖的词。
Next Sentence Prediction（NSP）： BERT 的预训练任务还包括了一个下一句预测任务，即判断两个句子是否是相邻的。这有助于模型理解文本中句子之间的关系。

BERT 在自然语言处理任务中取得了显著的性能提升，成为了许多 NLP 任务中的基准模型。其预训练的语言表示可以用于文本分类、命名实体识别、文本相似度等多个下游任务。

自身优缺点

BERT（Bidirectional Encoder Representations from Transformers）作为一种强大的自然语言处理模型，具有一些优点和缺点。以下是BERT模型的一些关键优缺点：

优点：

上下文理解： BERT 采用双向编码，能够更好地理解文本中的上下文和语境，从而提高对语言的理解能力。
预训练能力： BERT 在大规模语料库上进行预训练，学习到通用的语言表示，使得它能够在多个下游任务上进行微调而不需要大量标注数据。
多任务适应： 由于预训练阶段的通用性，BERT 可以用于多种自然语言处理任务，如文本分类、命名实体识别、语义相似度等。
Transformer 架构： BERT 基于Transformer模型，该模型在处理长距离依赖和捕捉全局关系方面表现出色。
强大的表征能力： BERT 学到的语言表示具有强大的表征能力，能够捕捉词汇、语法和语义之间的复杂关系。

缺点：

计算资源需求： BERT 模型相对较大，需要大量的计算资源进行预训练和微调，这使得在资源受限的环境中应用受到挑战。
存储空间： BERT 模型的存储空间较大，对于一些嵌入式设备或资源受限的应用场景可能不太适用。
不适用于实时系统： BERT 的计算复杂度较高，不太适用于实时系统，对于一些需要低延迟的应用可能存在困难。
无法处理超出训练范围的词汇： BERT 在预训练时使用了固定的词汇表，无法处理超出训练范围的词汇，这可能限制其在一些特定领域的适用性。
对标注数据的依赖： 在微调阶段，BERT 需要标注数据进行监督学习，对于某些领域缺乏大规模标注数据的情况可能不太适用。

总体而言，BERT 在处理自然语言处理任务中表现出色，但在使用时需要考虑计算资源、存储需求和实时性等方面的限制。在不同的应用场景中，可能需要权衡其优势和缺点。

代码

import torch
from transformers import BertTokenizer, BertModel
from sklearn.metrics.pairwise import cosine_similarity
import time
import numpy as np
from docx import Document
import torch
from transformers import BertTokenizer, BertModel
from sklearn.metrics.pairwise import cosine_similarity


# 读取文档内容
def read_docx(docx_path):
    doc = Document(docx_path)
    text = ""
    for paragraph in doc.paragraphs:
        if paragraph.text == "" and text != "":
            text = text + "\n"
        text = text + paragraph.text
    return text


# 文本预处理
def preprocess_text(text):
    # 可以根据需要进行文本清洗、分句等预处理
    return text


# BERT编码
# BERT编码
def bert_encode(text, model, tokenizer):
    tokens = tokenizer.encode(text, return_tensors='pt', max_length=512, truncation=True)
    with torch.no_grad():
        outputs = model(tokens)
    return outputs.pooler_output.squeeze().numpy()


# 计算相似度
def calculate_similarity(embeddings):
    embeddings_2d = [emb.flatten() for emb in embeddings]
    return cosine_similarity(embeddings_2d)


# 分割文档
def segment_document(paragraphs, similarity_matrix, threshold):
    segments = []
    current_segment = [paragraphs[0]]

    for i in range(1, len(paragraphs)):
        if similarity_matrix[0, i] < threshold:
            segments.append(current_segment)
            current_segment = [paragraphs[i]]
        else:
            current_segment.append(paragraphs[i])

    segments.append(current_segment)
    return segments

start_time = time.time()
# 示例用法
# docx_path = "南京农业大学发展史（1902—2022）(1).docx"
docx_path = "第一篇(1).docx"
# docx_path = "漫修股家团队介绍（电子版）改.docx"
document = read_docx(docx_path)
document = preprocess_text(document)
end_time = time.time()
execution_time = end_time - start_time
print("加载文件：", execution_time, "秒")

start_time = time.time()
# 加载BERT模型和分词器
model_name = 'bert-base-chinese'
model = BertModel.from_pretrained(model_name)
tokenizer = BertTokenizer.from_pretrained(model_name)
end_time = time.time()
execution_time = end_time - start_time
print("加载BERT模型和分词器：", execution_time, "秒")

start_time = time.time()
# 对每个段落进行BERT编码
paragraphs = document.split('\n')  # 假设每个段落以换行符分隔
embeddings = [bert_encode(paragraph, model, tokenizer) for paragraph in paragraphs]
end_time = time.time()
execution_time = end_time - start_time
print("对每个段落进行BERT编码：", execution_time, "秒")

start_time = time.time()
# 计算相似度矩阵
similarity_matrix = calculate_similarity(embeddings)
end_time = time.time()
execution_time = end_time - start_time
print("计算相似度矩阵：", execution_time, "秒")

# 设置相似度阈值
threshold = 0.95
start_time = time.time()
# 分割文档
segments = segment_document(paragraphs, similarity_matrix, threshold)
end_time = time.time()
execution_time = end_time - start_time
print("分割文档：", execution_time, "秒")

start_time = time.time()

# 打印分割后的文档
with open("bert-base-chinese-university-第一篇.txt", "a", encoding="utf-8") as file:
# with open("bert-layer.txt", "a", encoding="utf-8") as file:
    for segment in segments:
        file.write("----------\n")
        # 将嵌套的列表拼接成一个字符串，并在每个子列表之间添加换行
        for s in segment:
            file.write(s + "\n")
        print("\n".join(segment))

end_time = time.time()
execution_time = end_time - start_time
print("程序运行时间为：", execution_time, "秒")

应用文档分割优点

速度比较快，分割符合逻辑

应用文档分割缺点

分割粗糙、分割段落块太大

text2vect

介绍

文本向量化（text2vec）是将文本数据转换为机器学习算法可以处理的数字表示（向量）的过程。这在各种自然语言处理（NLP）任务中都至关重要，因为算法无法直接理解原始文本。

为什么文本向量化是必要的？

机器学习算法处理数字数据：文本是无结构的，固有具有语言性，需要转换成算法可以处理的格式。
向量表示捕捉有意义的模式：它们编码了词语、短语和概念之间的语义关系，允许算法提取洞察力并对语言进行预测。

常用的文本向量化技术

词袋模型（Bag-of-Words，BoW）：
- 将文本表示为词计数的集合，忽略词序。
- 简单但对于任务如文本分类往往有效。
TF-IDF（Term Frequency-Inverse Document Frequency）：
- 根据词在文档中出现的频率和在文档集合中出现的稀有程度来加权词。
- 给予独特且有信息量的词更大的权重。
词嵌入（Word Embedding）：
- 将词表示为多维空间中的稠密向量，语义相似的词更靠近。
- 捕捉词之间的上下文关系，提高各种 NLP 任务的性能。
- 流行的方法包括 Word2Vec、GloVe 和 fastText。

文本向量化的应用

文本分类：将文档分类（例如垃圾邮件检测、情感分析）
信息检索：根据查询与文档相关性的顺序排列文档（例如搜索引擎）
主题建模：发现文本集合中的潜在主题
机器翻译：将文本从一种语言翻译成另一种语言
问答：生成自然语言问题的答案
文本摘要：创建文本文档的简洁摘要
聊天机器人和虚拟助手：理解和响应用户的自然语言查询

文本向量化的工具和库

Python：scikit-learn、Gensim、spaCy
R：text2vec 包
Java：MALLET
TensorFlow：tf.keras.layers.Embedding

选择合适的文本向量化技术取决于具体的 NLP 任务和所需的语义理解水平。

自身优缺点

优点：

可以将文本数据转换为机器学习算法可以处理的格式，使其能够对文本进行处理和分析。
可以捕捉文本中具有意义的模式，例如词语、短语和概念之间的语义关系。
可以提高各种 NLP 任务的性能，例如文本分类、信息检索、主题建模、机器翻译、问答、文本摘要等。

缺点：

维数灾难：随着词汇量的增加，文本向量化的维度也会增加，这会导致计算量和存储量增加，并可能导致过拟合。
缺乏语义理解：文本向量化只是将文本数据转换为数字表示，无法完全理解文本的语义。
需要大量的训练数据：文本向量化算法需要大量的训练数据才能达到良好的效果。

总体而言，文本向量化是一种有效的技术，可以帮助机器学习算法理解和处理文本数据。但是，在使用文本向量化时，需要注意其优缺点，并根据具体的 NLP 任务选择合适的技术。

代码

import re

from core.xr.spiltter.chinese_recursive_text_splitter import ChineseRecursiveTextSplitter

import time
from docx import Document
import torch
from sklearn.metrics.pairwise import cosine_similarity
from text2vec import SentenceModel


# 读取文档内容
def read_docx(docx_path):
    doc = Document(docx_path)
    text = ""
    for paragraph in doc.paragraphs:
        if paragraph.text == "" and text != "":
            text = text + "\n"
        text = text + paragraph.text
    return text


# 文本预处理
def preprocess_text(text):
    # 可以根据需要进行文本清洗、分句等预处理
    return text


# 计算相似度
def calculate_similarity(embeddings):
    embeddings_2d = [emb.flatten() for emb in embeddings]
    return cosine_similarity(embeddings_2d)


# 分割文档
def segment_document(paragraphs, similarity_matrix, threshold):
    segments = []
    current_segment = [paragraphs[0]]

    for i in range(1, len(paragraphs)):
        if similarity_matrix[0, i] < threshold:
            segments.append(current_segment)
            current_segment = [paragraphs[i]]
        else:
            current_segment.append(paragraphs[i])

    segments.append(current_segment)
    return segments


def split_text(ls_text):
    text_splitter = ChineseRecursiveTextSplitter(
        keep_separator=True,
        is_separator_regex=True,
        chunk_size=150,
        chunk_overlap=30
    )
    ls = [
        ls_text
    ]
    chunks = None
    for inum, text in enumerate(ls):
        chunks = text_splitter.split_text(text)
    return chunks


def compute_emb(model, sentences):
    sentence_embeddings = model.encode(sentences)
    print(type(sentence_embeddings), sentence_embeddings.shape)
    for sentence, embedding in zip(sentences, sentence_embeddings):
        print("Sentence:", sentence)
        print("Embedding shape:", embedding.shape)
        print("Embedding head:", embedding[:10])
        print()
    return sentence_embeddings


def main(model, threshold):
    t2v_model = SentenceModel("" + model)
    embeddings2 = compute_emb(t2v_model, paragraphs)
    print("对每个段落进行BERT编码")
    similarity_matrix = calculate_similarity(embeddings2)
    print("计算相似度矩阵")

    # 设置相似度阈值 分割文档
    segments = segment_document(paragraphs, similarity_matrix, threshold)
    with open(f"{re.search(r'/([^/]+)$', model)[0][1:]}-{threshold}.txt", "a", encoding="utf-8") as file:
        for segment in segments:
            file.write("----------\n")
            # 将嵌套的列表拼接成一个字符串，并在每个子列表之间添加换行
            for s in segment:
                file.write(s + "\n")
            print("\n".join(segment))


start_time = time.time()

docx_path = 你的文章路径
document = read_docx(docx_path)
document = preprocess_text(document)
paragraphs = split_text(document)
models = [
    # "shibing624/text2vec-base-chinese",
    # "shibing624/text2vec-base-chinese-paraphrase",
    "shibing624/text2vec-base-chinese-sentence",
    # "shibing624/text2vec-bge-large-chinese",
    # "shibing624/text2vec-base-chinese-nli",#旧版text2vec-base-chinese-sentence
    # "hfl/chinese-macbert-base", # 我用着效果不行
    # "hfl/chinese-roberta-wwm-ext",# 还行，就是参数不好确定
    # "uer/roberta-medium-wwm-chinese-cluecorpussmall"
]
# "w2v-light-tencent-chinese", 需要单独下载 https://ai.tencent.com/ailab/nlp/en/download.html
# "w2v-light-tencent-chines",, 需要单独下载 https://ai.tencent.com/ailab/nlp/en/download.html
thresholds = [0.6, 0.75, 0.9] 
for model in models:
    for threshold in thresholds:
        main(model, threshold)
        print(f"******************{model}{threshold}********************")
end_time = time.time()
execution_time = end_time - start_time
print("程序运行时间为：", execution_time, "秒")

应用文档分割优点

可使用的向量模型多，方便个性化选择
速度较快，效果较好

应用文档分割缺点

不如chatgpt逻辑性更强，缺乏上下文深度理解、对于上下文联系的认知

对比

名称	chatgpt + langchain	NLTK	BERT	text2vect
速度排序	4	2	3	1
效果排序	1	4	3	2

向日葵花籽儿

关注

20
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
# AIGC应用 ## 深度学习#向量数据库知识问答前期操作：文档切割/文档向量/chatgpt + langchain| NLTK | BERT | text2vect |

本文是利用chatgpt + langchain| NLTK | BERT | text2vect |四种文档切割的效果测试研究，附上源码可以自己实践
复制链接

扫一扫