Compartir tecnología

LLM_Guía de introducción (construcción de un modelo grande desde cero conceptos básicos)

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Este artículo presenta principalmente indicaciones para modelos grandes y ofrece tutoriales prácticos. Se pueden construir modelos grandes incluso sin cimientos.

Contenido: La etapa inicial del entrenamiento mental ayuda a condensar y potenciar la fuerza interna y sienta las bases para el entrenamiento posterior.

1、aviso

1.1 Significado y función

rápido significa impulsar el proyecto. En modelos de lenguaje grande, un "mensaje" se refiere a texto de entrada o instrucciones proporcionadas por el usuario al modelo para guiarlo a generar la salida correspondiente. La indicación juega un papel vital al interactuar con el modelo, lo que afecta la comprensión del modelo, la precisión de las respuestas y la creatividad del contenido. Los siguientes son los principales significados y funciones del aviso en modelos grandes:

a.Generación de modelos de guía. : El mensaje proporciona la información inicial y la dirección que necesita el modelo para generar una respuesta o resultado. Puede contener preguntas, instrucciones, palabras clave o información contextual para ayudar al modelo a comprender las intenciones y necesidades del usuario y generar la información correspondiente en base a esto.

b.comprensión contextual : A través de indicaciones, el modelo puede comprender el contexto de la conversación o tarea actual. Esto es fundamental para garantizar que el modelo genere respuestas que sean relevantes y coherentes con las expectativas de los usuarios, especialmente en interacciones a largo plazo o múltiples rondas de conversaciones.

c. Precisión de la respuesta : Una pregunta clara y detallada normalmente conducirá a una respuesta más precisa. Si el mensaje describe claramente el problema o la necesidad del usuario, el modelo puede proporcionar más fácilmente la información o las soluciones esperadas.

d. Generar diversidad : Aunque el aviso proporciona orientación para el modelo, no limita la creatividad del modelo ni la diversidad de resultados. Las indicaciones adecuadas pueden inspirar a los modelos a producir soluciones novedosas o no obvias manteniendo la precisión.

mi.orientación a la tarea : En algunos escenarios de aplicación, el mensaje puede especificar las tareas que el modelo debe realizar o el tipo de generación, como responder preguntas, brindar sugerencias, describir escenarios, etc. Esta guía ayuda a garantizar que los resultados del modelo coincidan con las necesidades de una tarea o aplicación específica.

F.Estilo y formato del lenguaje : A través del mensaje, los usuarios pueden configurar el estilo de idioma deseado, la estructura de respuesta o el formato de información específico. Esto es fundamental para garantizar la calidad general de la salida del modelo y la experiencia del usuario.

En resumen, el aviso sirve como puente y guía para la interacción entre usuarios y modelos en modelos de lenguaje grandes, y desempeña un papel clave al afectar la precisión, relevancia y diversidad de la salida del modelo. La creación y el uso eficaces de indicaciones pueden mejorar significativamente la utilidad y la capacidad de respuesta de su modelo.

1.2 Principios

Cuando se trata de indicaciones en modelos de lenguaje grandes, existen varios principios que generalmente se consideran y siguen:

a. Orientación clara y concisa:prompt debe expresar claramente las necesidades o preguntas del usuario y evitar descripciones vagas o ambiguas para garantizar que el modelo pueda comprender y proporcionar respuestas relevantes y precisas.

b.orientación contextual: Si la pregunta o el requisito involucra un trasfondo o contexto específico, el mensaje debe contener la información necesaria para ayudar al modelo a comprender, como palabras clave relevantes o información relacionada.

C.instrucciones específicas :El mensaje debe contener instrucciones o preguntas específicas para que el modelo conozca el tipo y formato de salida que espera el usuario. Por ejemplo, al preguntar sobre las atracciones turísticas de una ciudad, puede especificar claramente que necesita nombres de atracciones, sugerencias de actividades o información de transporte.

d. Evite la orientación excesiva: Si bien es útil brindar algo de contexto y orientación, evite ser demasiado instructivo o brindar demasiados detalles para no limitar la creatividad del modelo y la diversidad de respuestas.

mi.El lenguaje es conciso y claro.: Escriba indicaciones en un lenguaje claro, conciso y natural para que el modelo pueda entenderlas y procesarlas fácilmente.

f. Probar y ajustar: En aplicaciones del mundo real, es importante probar y ajustar las indicaciones para garantizar que el modelo funcione como se espera y pueda manejar una variedad de entradas de manera eficiente.

Estos principios ayudan a garantizar que los modelos de lenguaje grandes sean eficientes, precisos y creativos en sus interacciones con los usuarios.

En resumen: el aviso es un punto de partida que brinda una pista, orientación y estandarización al modelo grande.

1.3 Habilidades de uso

un separador

Por ejemplo: proporcione un párrafo y pídale a GPT que lo resuma. En este ejemplo usamos ``` como delimitador.

  1. from tool import get_completion
  2. text = """您应该提供尽可能清晰、具体的指示，以表达您希望模型执行的任务。这将引导模型朝向所
  3. 需的输出，并降低收到无关或不正确响应的可能性。不要将写清晰的提示词与写简短的提示词混淆。在
  4. 许多情况下，更长的提示词可以为模型提供更多的清晰度和上下文信息，从而导致更详细和相关的输出。
  5. """ # 需要总结的文本内容
  6. prompt = f"""把用三个反引号括起来的文本总结成一句话。```
                    
            本文主要介绍大模型的prompt，并且给出实战教程。即使零基础也可以实现大模型的搭建。
     

    内容：初级阶段的修炼心法，帮助凝聚和提升内力，为后续修炼打下基础。
     

    1、prompt
     

    1.1含义和作用
     

            prompt就是提示工程的意思。在大型语言模型中，"prompt"（提示）指的是用户提供给模型的输入文本或指令，用来指导模型生成相应的输出。Prompt在与模型交互时起着至关重要的作用，它影响着模型的理解、回答的准确性和内容的创造性。以下是prompt在大模型中的主要含义和作用：
     

            a. 指导模型生成：Prompt提供了模型生成回复或输出所需的初始信息和方向。它可以包含问题、指令、关键词或上下文信息，帮助模型理解用户的意图和需要，并基于此进行相应的生成。
     

            b. 上下文理解：通过prompt，模型能够了解当前对话或任务的上下文。这对于确保模型生成与用户期望相关和连贯的回复至关重要，特别是在长期交互或多轮对话中。
     

            c.回答准确性：一个清晰和详细的prompt通常会导致更准确的回答。如果prompt描述清楚用户的问题或需求，模型就能更容易地提供符合预期的信息或解决方案。
     

            d.生成多样性：尽管prompt为模型提供了指导，但它并不限制模型的创造性和输出的多样性。合适的prompt可以在保持准确性的同时，激发模型产生新颖或非显而易见的解答。
     

            e. 任务定向：在一些应用场景中，prompt可以具体指定模型需要执行的任务或生成的类型，如回答问题、提供建议、描述情景等。这种指导有助于确保模型输出与特定任务或应用的需求相符。
     

            f. 语言风格和格式：通过prompt，用户可以设定期望的语言风格、回答的结构或特定的信息格式。这对于确保模型输出的整体质量和用户体验至关重要。
     

            总之，prompt在大型语言模型中充当了用户与模型之间交互的桥梁和指南，对于影响模型输出的准确性、相关性和多样性起着关键作用。有效地构建和使用prompt可以显著提高模型的实用性和响应能力。
     

    1.2原则
     

            在处理大型语言模型中的prompt时，有几个原则是通常被考虑和遵循的：
     

            a.清晰和简洁的指导：prompt应该明确表达用户的需求或者问题，避免模糊或多义的描述，以确保模型能够理解并提供相关和准确的回答。
     

            b. 上下文的引导：如果问题或需求涉及到特定的背景或上下文，prompt应该包含必要的信息来帮助模型理解，比如相关的关键词或相关信息。
     

            c. 具体的指令：prompt中应包含具体的指令或问题，以便模型知道用户期望的输出类型和格式。例如，询问一个城市的旅游景点时，可以明确指定需要景点名称、活动建议或交通信息等。
     

            d.避免过度指导：虽然提供一些上下文和指导是有益的，但避免过度指导或提供过多细节，以免限制模型的创造性和回答的多样性。
     

            e. 语言简洁明了：使用清晰、简洁和自然的语言编写prompt，以便模型能够轻松理解和处理。
     

            f.测试和调整：在实际应用中，对prompt进行测试和调整是很重要的，以确保模型能够按预期工作，并且能够有效地处理各种输入。
     

            这些原则有助于确保大型语言模型能够在与用户的交互中表现出高效、准确和有创意的特性。
     

            总之：prompt就是一个起点，给大模型一个提示、引导和规范的作用。
     

    1.3使用技巧
     

            a.分隔符
     

            eg：给出一段话并要求 GPT 进行总结，在该示例中我们使用 ``` 来作为分隔符。
     

    1. from tool import get_completion
    2. text = """您应该提供尽可能清晰、具体的指示，以表达您希望模型执行的任务。这将引导模型朝向所
    3. 需的输出，并降低收到无关或不正确响应的可能性。不要将写清晰的提示词与写简短的提示词混淆。在
    4. 许多情况下，更长的提示词可以为模型提供更多的清晰度和上下文信息，从而导致更详细和相关的输出。
    5. """ # 需要总结的文本内容
    6. prompt = f"""把用三个反引号括起来的文本总结成一句话。```{text}```""" # 指令内容，使用 ``` 来分隔指令和待总结的内容
    7. response = get_completion(prompt)
    8. print(response)
    9. # 为了获得所需的输出，您应该提供清晰、具体的指示，避免与简短的提示词混淆，并使用更长的提示
    10. 词来提供更多的清晰度和上下文信息。
     

              b.结构化输出
     

            eg：生成三本书的标题、作者和类别，并以 JSON 的格式返回，为便于解析，我们指定了 Json 的键: book_id、title、author、genre。
     

    1. prompt = f"""请生成包括书名、作者和类别的虚构的、非真实存在的中文书籍清单，并以 JSON 格式
    2. 提供，其中包含以下键:book_id、title、author、genre。"""
    3. response = get_completion(prompt)
    4. print(response)
    5. [
    6. { "book_id": 1, "title": "幻境之夜", "author": "李梦飞", "genre": "奇幻小说"
    7. },
    8. ... ]
     

            c.参考示例
     

             Zero-Shot提示：模型只根据任务的描述生成响应，不需要任何示例。
     

             One-Shot提示：只提供一个例子。
     

            Few-Shot提示：提供几个例子。在提示中的作用是通过少量样本引导模型对特定任务进行学习和执行，例如通过提供少量风格或主题示例，引导模型产出具有相似风格或主题的创作。
     

            d.让模型充当角色
     

            示例：请以莎士比亚戏剧中的哈姆雷特的身份解释“生存还是毁灭，这是一个问题”。这个示例要求模型以莎士比亚戏剧《哈姆雷特》中主人公的角色来解释著名的“生存还是毁灭”的问题，以展示模型在不同角色中的表现能力和语境理解能力。
     

     

    2、模型实战
     

            项目任务（三大业务场景）：
     

            1.文本分类
     

            2.文本信息抽取
     

            3.文本匹配
     

            大模型选择：ChatGLM-6B
     

            采用方法：基于Few-Shot+Zero-Shot以及Instrunction的思想，设计prompt, 进而应用ChatGLM-6B模型完成相应的任务
     

    2.1 准备工作
     

            a.我们运用python环境来执行大模型，所以首先需要下载python,(建议用anaconda)
     

            b.下载ChatGLM-6B模型模型，链接如下：
     

                    https://github.com/THUDM/ChatGLM-6B?tab=readme-ov-file
     

                    README中介绍了ChatGLM-6B模型和硬件需求。
     

    量化等级最低 GPU 显存（推理）最低 GPU 显存（高效参数微调）
    FP16（无量化）13 GB14 GB
    INT88 GB9 GB
    INT46 GB7 GB
     

            c.在你的anaconda中安装需要的依赖。在前面github中下载的包中，它其实把所有需要的依赖都放在了requirements.txt中，直接输入：
     

            pip install -r requirements.txt
     

            如果下载速度很慢，加上清华镜像
     

            pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
     

            其中 transformers 库版本推荐为 4.27.1，但理论上不低于 4.23.1 即可。
     

            此外，如果需要在 cpu 上运行量化后的模型，还需要安装 gcc 与 openmp。多数 Linux 发行版默认已安装。Windows 测试环境 gcc 版本为 TDM-GCC 10.3.0， Linux 为 gcc 11.3.0。
     

            d.从本地加载模型：
     

            以上代码会由 transformers 自动下载模型实现和参数。完整的模型实现可以在 Hugging Face Hub。如果你的网络环境较差，下载模型参数可能会花费较长时间甚至失败。此时可以先将模型下载到本地，然后从本地加载。
     

            从 Hugging Face Hub 下载模型需要先安装Git LFS，然后运行
     

    git clone https://huggingface.co/THUDM/chatglm-6b
     

    如果你从 Hugging Face Hub 上下载 checkpoint 的速度较慢，可以只下载模型实现
     

    GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/THUDM/chatglm-6b
     

            然后从这里手动下载模型参数文件，并将下载的文件替换到本地的 chatglm-6b 目录下。
     

            将模型下载到本地之后，将以上代码中的 THUDM/chatglm-6b 替换为你本地的 chatglm-6b 文件夹的路径，即可从本地加载模型。
     

            MAC注意
     

            Mac直接加载量化后的模型出现提示 `clang: error: unsupported option '-fopenmp'
     

            这是由于Mac由于本身缺乏omp导致的，此时可运行但是单核。需要单独安装 openmp 依赖，即可在Mac下使用OMP：
     

    1. # 参考`https://mac.r-project.org/openmp/`
    2. ## 假设: gcc(clang)是14.x版本，其他版本见R-Project提供的表格
    3. curl -O https://mac.r-project.org/openmp/openmp-14.0.6-darwin20-Release.tar.gz
    4. sudo tar fvxz openmp-14.0.6-darwin20-Release.tar.gz -C /
     

    此时会安装下面几个文件：/usr/local/lib/libomp.dylib, /usr/local/include/ompt.h, /usr/local/include/omp.h, /usr/local/include/omp-tools.h。
     

     
 
    注意：如果你之前运行ChatGLM项目失败过，最好清一下Huggingface的缓存，i.e. 默认下是 rm -rf ${HOME}/.cache/huggingface/modules/transformers_modules/chatglm-6b-int4。由于使用了rm命令，请明确知道自己在删除什么。
     

     

            这是官方给的解决方案，我没成功。我是在代码上加入如下：
     

    1. import os
    2. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
     

            防止了mac执行报错。
     

    2.2 文本分类
     

            我们的目的是期望模型能够帮助我们识别出这4段话中，每一句话描述的是一个什么类型的报告。
     

    1. sentences = [
    2.         "今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。",
    3.         "ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。",
    4.         "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
     

            对于大模型来讲，prompt 的设计非常重要，一个 明确 的 prompt 能够帮助我们更好从大模型中获得我们想要的结果。
     

    在该任务的 prompt 设计中，我们主要考虑 2 点：
     

            1、需要向模型解释什么叫作「文本分类任务」
     

            2、需要让模型按照我们指定的格式输出
     

            2.2.1导入包
     

    1. """
    2. 利用 LLM 进行文本分类任务。
    3. """
    4. from rich import print
    5. from rich.console import Console
    6. from transformers import AutoTokenizer, AutoModel
    7. import os
    8. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
     

            2.2.2 定义init_prompts函数
     

    1. # 提供所有类别以及每个类别下的样例
    2. class_examples ={
    3. '新闻报道':'今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。',
    4. '财务报告':'本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。',
    5. '公司公告':'本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力',
    6. '分析师报告':'最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势'}
    7.  
    8. # 定义init_prompts函数
    9. definit_prompts():
    10. '''
    11.     这里是对函数的功能进行注释，方便他人理解：该函数的目的是初始化前置prompt,便于模型做Few-shot
    12.     :return: dict字典
    13.     '''
    14.     class_list =list(class_examples.keys())
    15. print(f'分类的类别数：{class_list}')
    16.  
    17.     pre_history =[
    18. (f'现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：{class_list}类别中。',
    19. f'好的。')
    20. ]
    21. # 遍历给的示例样本
    22. for _type, example in class_examples.items():
    23. # print(f'键--》{_type}')
    24. # print(f'值--》{example}')
    25.         pre_history.append((f'"{example}"是{class_list}里的什么类别', _type))
    26.  
    27. # print(f'pre_history--》{pre_history}')
    28. return{"class_list":class_list,"pre_history":pre_history}
     

            a.提供一个Few-shot的样例，标注每个类别对应的话
     

            b.将类别存储到class_list中
     

            c.在样本提供之前给予一个prompt。即告诉模型。你是个文本分类器，要具体做什么？并给予一个答案（以逗号分隔）。（相当于一个有监督的训练）
     

            d.遍历给的示例样本，添加到pre_history
     

            e.返回一个字典。
     

            打印的结果如下：
     

    1. 分类的类别数：['新闻报道','财务报告','公司公告','分析师报告']
    2. 键--》新闻报道
    3. 值--》今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。
    4. 键--》财务报告
    5. 值--》本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。
    6. 键--》公司公告
    7. 值--》本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力
    8. 键--》分析师报告
    9. 值--》最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势
    10. pre_history--》[("现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：['新闻报道', '财务报告', '公司公告', '分析师报告']类别中。",'好的。'),('"今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','新闻报道'),('"本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','财务报告'),('"本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','公司公告'),('"最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','分析师报告')]
     

    2.2.3 定义inference函数
     

    1.     sentences = [
    2. "今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。",
    3. "ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。",
    4. "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
    5. "最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会",
    6. ]
    7.  
    8. definference(sentences: list,
    9.               custom_settings: dict):
    10. """
    11.     推理函数。
    13.     Args:
    14.         sentences (List[str]): 待推理的句子。
    15.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
    16.     """
    17. for sentence in sentences:
    18. #没啥含义，就是改变打印的颜色。
    19. with console.status("[bold bright_green] Model Inference..."):
    20. #
    21.             sentence_prompt =f'"{sentence}"是{custom_settings["class_list"]}里的什么类别？'
    22.             response, history = model.chat(tokenizer, sentence_prompt, history=custom_settings['pre_history'])
    23. print(f'>>>[bold bright_red]sentence:{sentence}')
    24. print(f'>>>[bold bright_green]inference answer:{response}')
    25. print(f'history-->{history}')
    26. print("*"*80)
     

    输入：
     

    1、sentences ：待推理的句子。
     

    2、custom_settings ：init_prompts准备好的 提示工程。
     

    流程：
     

    1、遍历需要推理的句子
     

    2、执行核心代码model.chat(tokenizer, sentence_prompt, history=custom_settings['pre_history'])
     

    其中：
     

    tokenizer：就是代码的分词器（可以理解为单词的最小单元）
     

    sentence_prompt：将问题句子补充成完成的prompt
     

    history：之前准备好的历史语句
     

    打印的结果：
     

    1. >>>sentence:今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。
    2. >>>inference answer:新闻报道
    3. >>>sentence:ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩
    4. 固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。
    5. >>>inference answer:公司公告
    6. ********************************************************************************
    7. >>>sentence:公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。
    8. >>>inference answer:财务报告
    9. ********************************************************************************
    10. >>>sentence:最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会
    11. >>>inference answer:分析师报告
     

    可以看到分类成功了，此时我有大胆的想法。如果我输入一句和所有类别毫不相关的话会怎么样？
     

    sentences = ["我今天中午和朋友吃了牛肉粉丝汤，不小心洒了一地"]
     

    它会打印成：新闻报道
     

    这时候只要在prompt增加：
     

    1. "现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：['新闻
    2. 报道', '财务报告', '公司公告', '分析师报告']类别中。如果都不是就输出：'其他' ",
     

    结果就可以变成：
     

    1. >>>sentence:我今天中午和朋友吃了牛肉粉丝汤，不小心洒了一地
    2. >>>inference answer:其他
     

    2.2.4 完整代码
     

    1. # —*-coding:utf-8-*-
    2. """
    3. 利用 LLM 进行文本分类任务。
    4. """
    5. from rich importprint
    6. from rich.console importConsole
    7. from transformers importAutoTokenizer,AutoModel
    8. import os
    9. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
    10.  
    11.  
    12. # 提供所有类别以及每个类别下的样例
    13. class_examples ={
    14. '新闻报道':'今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。',
    15. '财务报告':'本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。',
    16. '公司公告':'本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力',
    17. '分析师报告':'最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势'}
    18.  
    19. # 定义init_prompts函数
    20. definit_prompts():
    21. '''
    22.     这里是对函数的功能进行注释，方便他人理解：该函数的目的是初始化前置prompt,便于模型做Few-shot
    23.     :return: dict字典
    24.     '''
    25.     class_list =list(class_examples.keys())
    26. print(f'分类的类别数：{class_list}')
    27.  
    28.     pre_history =[
    29. (f'现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：{class_list}类别中。',
    30. f'好的。')
    31. ]
    32. # 遍历给的示例样本
    33. for _type, example in class_examples.items():
    34. # print(f'键--》{_type}')
    35. # print(f'值--》{example}')
    36.         pre_history.append((f'"{example}"是{class_list}里的什么类别', _type))
    37.  
    38. # print(f'pre_history--》{pre_history}')
    39. return{"class_list":class_list,"pre_history":pre_history}
    40.  
    41. definference(sentences: list,
    42.               custom_settings: dict):
    43. """
    44.     推理函数。
    46.     Args:
    47.         sentences (List[str]): 待推理的句子。
    48.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
    49.     """
    50. for sentence in sentences:
    51. with console.status("[bold bright_green] Model Inference..."):
    52.             sentence_prompt =f'"{sentence}"是{custom_settings["class_list"]}里的什么类别？'
    53.             response, history = model.chat(tokenizer, sentence_prompt, history=custom_settings['pre_history'])
    54. print(f'>>>[bold bright_red]sentence:{sentence}')
    55. print(f'>>>[bold bright_green]inference answer:{response}')
    56. print(f'history-->{history}')
    57. print("*"*80)
    58.  
    59.  
    60. if __name__ =='__main__':
    61.     console =Console()
    62. #device = 'cuda:0'
    63.     device ='cpu'
    64.     tokenizer =AutoTokenizer.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",trust_remote_code=True)
    65. # model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b", trust_remote_code=True).half().cuda()
    66.     model =AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",trust_remote_code=True).float()
    67.     model.to(device)
    68.  
    69. # sentences = [
    70. #     "今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。",
    71. #     "ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。",
    72. #     "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
    73. #     "最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会",
    74. #     ]
    75. # sentences = ["金融系统是建设金融强国责无旁贷的主力军，必须切实把思想和行动统一到党中央决策部署上来，深刻把握建设金融强国的精髓要义和实践要求，不断增强使命感、责任感，推动宏伟蓝图一步步变成美好现实"]
    76.     sentences =["我今天中午和朋友吃了牛肉粉丝汤，不小心洒了一地"]
    77.     custom_settings = init_prompts()
    78. print(custom_settings)
    79.  
    80.     inference(
    81.         sentences,
    82.         custom_settings
    83.     )
     

            主函数主要调用本次使用的tokenizer和model。
     

    注意：
     

            如果用mac在执行过程中选用了chatglm-6b-int4模型，会报错，
     

    1.     logger.warning("Failed to load cpm_kernels:", exception)
    2. Message: 'Failed to load cpm_kernels:'
    3. Arguments: (RuntimeError('Unknown platform: darwin'),)
     

            还能执行的话就不用管他，实在不行就切换成chatglm-6b模型即可。
     

           如果你要用gpu跑模型，可以用这个代码替换
     

    # model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b", trust_remote_code=True).half().cuda()
     

    2.3 文本信息抽取
     

            其实文本信息抽取也是一致的主要还是实现init_prompts函数和inference函数
     

    2.3.1 实现init_prompts函数
     

    1. import re
    2. import json
    3.  
    4.  
    5. from rich importprint
    6. from transformers importAutoTokenizer,AutoModel
    7. import os
    8. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
    9.  
    10. # 定义不同实体下的具备属性
    11. schema ={
    12. '金融':['日期','股票名称','开盘价','收盘价','成交量'],
    13. }
    14.  
    15. # 信息抽取的模版
    16. IE_PATTERN ="{}nn提取上述句子中{}的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表示，多个值之间用','分隔。"
    17.  
    18.  
    19. # 提供一些例子供模型参考
    20. ie_examples ={
    21. '金融':[
    22. {
    23. 'content':'2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元，随后回落至98美元，最终以102美元收盘，成交量达到520000。',
    24. 'answers':{
    25. '日期':['2023-01-10'],
    26. '股票名称':['古哥-D[EOOE]美股'],
    27. '开盘价':['100美元'],
    28. '收盘价':['102美元'],
    29. '成交量':['520000'],
    30. }
    31. }
    32. ]
    33. }
    34.  
    35.  
    36. # 定义init_prompts函数
    37. definit_prompts():
    38. """
    39.      初始化前置prompt，便于模型做 incontext learning。
    40.      """
    41.     ie_pre_history =[
    42. (
    43. "现在你需要帮助我完成信息抽取任务，当我给你一个句子时，你需要帮我抽取出句子中实体信息，并按照JSON的格式输出，上述句子中没有的信息用['原文中未提及']来表示，多个值之间用','分隔。",
    44. '好的，请输入您的句子。'
    45. )
    46. ]
    47. for _type, example_list in ie_examples.items():
    48. print(f'_type-->{_type}')
    49. print(f'example_list-->{example_list}')
    50. print(f'*'*80)
    51. for example in example_list:
    52.             sentence = example["content"]
    53.             properties_str =', '.join(schema[_type])
    54. print(f'properties_str-->{properties_str}')
    55.             schema_str_list =f'"{_type}"({properties_str})'
    56. print(f'schema_str_list-->{schema_str_list}')
    57.  
    58.             sentence_with_prompt = IE_PATTERN.format(sentence, schema_str_list)
    59. print(f'sentence_with_prompt-->{sentence_with_prompt}')
    60.             ie_pre_history.append((f"{sentence_with_prompt}",f"{json.dumps(example['answers'], ensure_ascii=False)}"))
    61. print(f'ie_pre_history-->{ie_pre_history}')
    62.  
    63. return{"ie_pre_history":ie_pre_history}
    64.  
    65. init_prompts()
     

    a.提供一个Few-shot的样例，定义不同实体下的具备属性
     

    b.将prompt补充完整
     

    c.增加至ie_pre_history当中
     

    打印如下：
     

    1. _type-->金融
    2. example_list-->[{'content':
    3. '2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元
    4. ，随后回落至98美元，最终以102美元收盘，成交量达到520000。','answers':{'日期':
    5. ['2023-01-10'],'股票名称':['古哥-D[EOOE]美股'],'开盘价':['100美元'],
    6. '收盘价':['102美元'],'成交量':['520000']}}]
    7. ********************************************************************************
    8. properties_str-->日期,股票名称,开盘价,收盘价,成交量
    9. schema_str_list-->"金融"(日期,股票名称,开盘价,收盘价,成交量)
    10. sentence_with_prompt-->2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美
    11. 元，一度飙升至105美元，随后回落至98美元，最终以102美元收盘，成交量达到520000。
    12.  
    13. 提取上述句子中"金融"(日期,股票名称,开盘价,收盘价,
    14. 成交量)的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表
    15. 示，多个值之间用','分隔。
    16. ie_pre_history-->[("现在你需要帮助我完成信息抽取任务，当我给你一个句子时，你需要
    17. 帮我抽取出句子中实体信息，并按照JSON的格式输出，上述句子中没有的信息用['原文中未
    18. 提及']来表示，多个值之间用','分隔。",'好的，请输入您的句子。'),
    19. ('2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元
    20. ，随后回落至98美元，最终以102美元收盘，成交量达到520000。nn提取上述句子中"金融
    21. "(日期, 股票名称, 开盘价, 收盘价, 
    22. 成交量)的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来
    23. 表示，多个值之间用','分隔。','{"日期": ["2023-01-10"], "股票名称": 
    24. ["古哥-D[EOOE]美股"], "开盘价": ["100美元"], "收盘价": ["102美元"], "成交量": 
    25. ["520000"]}')]
     

    2.3.2 定义inference函数
     

    1. def inference(sentences: list,
    2.               custom_settings: dict):
    3. """
    4.     推理函数。
    6.     Args:
    7.         sentences (List[str]): 待抽取的句子。
    8.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
    9.     """
    10. for sentence in sentences:
    11.         cls_res ="金融"
    12. if cls_res notin schema:
    13. print(f'The type model inferenced {cls_res} which is not in schema dict, exited.')
    14.             exit()
    15.         properties_str =', '.join(schema[cls_res])
    16.         schema_str_list =f'"{cls_res}"({properties_str})'
    17.         sentence_with_ie_prompt = IE_PATTERN.format(sentence, schema_str_list)
    18. # print(f'sentence_with_prompt-->{sentence_with_ie_prompt}')
    19.         ie_res, history = model.chat(tokenizer,
    20.                                      sentence_with_ie_prompt,
    21.                                      history=custom_settings["ie_pre_history"])
    22.         ie_res = clean_response(ie_res)
    23. print(f'>>> [bold bright_red]sentence: {sentence}')
    24. print(f'>>> [bold bright_green]inference answer:{ie_res} ')
     

    a.定义输入：
     

            sentences (List[str]): 待抽取的句子。custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
     

    b.定义类别：cls_res = "金融"
     

            这里将类别写死了。如果有多个类别。可以先利用 文本分类 实现后，在进行文本信息抽取。
     

    c.将输入的sentences补充完整，调用 model.chat
     

    d.将模型结果做一个后处理，提取json模型并输出
     

    打印如下：
     

    1. >>> sentence: 
    2. 2023-02-15，寓意吉祥的节日，股票佰笃[BD]美股开盘价10美元，虽然经历了波动，但最终
    3. 以13美元收盘，成交量微幅增加至460,000，投资者情绪较为平稳。
    4. >>> inference answer:{'日期': ['2023-02-15'], '股票名称': ['佰笃[BD]美股'], 
    5. '开盘价': ['10美元'], '收盘价': ['13美元'], '成交量': ['460,000']}
     

    2.3.3 完整代码
     

    1. import re
    2. import json
    3.  
    4.  
    5. from rich importprint
    6. from transformers importAutoTokenizer,AutoModel
    7. import os
    8. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
    9.  
    10. # 定义不同实体下的具备属性
    11. schema ={
    12. '金融':['日期','股票名称','开盘价','收盘价','成交量'],
    13. }
    14.  
    15. # 信息抽取的模版
    16. IE_PATTERN ="{}nn提取上述句子中{}的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表示，多个值之间用','分隔。"
    17.  
    18.  
    19. # 提供一些例子供模型参考
    20. ie_examples ={
    21. '金融':[
    22. {
    23. 'content':'2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元，随后回落至98美元，最终以102美元收盘，成交量达到520000。',
    24. 'answers':{
    25. '日期':['2023-01-10'],
    26. '股票名称':['古哥-D[EOOE]美股'],
    27. '开盘价':['100美元'],
    28. '收盘价':['102美元'],
    29. '成交量':['520000'],
    30. }
    31. }
    32. ]
    33. }
    34.  
    35. # 定义init_prompts函数
    36. definit_prompts():
    37. """
    38.      初始化前置prompt，便于模型做 incontext learning。
    39.      """
    40.     ie_pre_history =[
    41. (
    42. "现在你需要帮助我完成信息抽取任务，当我给你一个句子时，你需要帮我抽取出句子中实体信息，并按照JSON的格式输出，上述句子中没有的信息用['原文中未提及']来表示，多个值之间用','分隔。",
    43. '好的，请输入您的句子。'
    44. )
    45. ]
    46. for _type, example_list in ie_examples.items():
    47. # print(f'_type-->{_type}')
    48. # print(f'example_list-->{example_list}')
    49. # print(f'*'*80)
    50. for example in example_list:
    51.             sentence = example["content"]
    52.             properties_str =', '.join(schema[_type])
    53. # print(f'properties_str-->{properties_str}')
    54.             schema_str_list =f'"{_type}"({properties_str})'
    55. # print(f'schema_str_list-->{schema_str_list}')
    56.  
    57.             sentence_with_prompt = IE_PATTERN.format(sentence, schema_str_list)
    58. print(f'sentence_with_prompt-->{sentence_with_prompt}')
    59.             ie_pre_history.append((f"{sentence_with_prompt}",f"{json.dumps(example['answers'], ensure_ascii=False)}"))
    60. print(f'ie_pre_history-->{ie_pre_history}')
    61.  
    62. return{"ie_pre_history":ie_pre_history}
    63.  
    64. defclean_response(response: str):
    65. """
    66.     后处理模型输出。
    68.     Args:
    69.         response (str): _description_
    70.     """
    71. if'```json'in response:
    72.         res = re.findall(r'```json(.*?)```', response)
    73. iflen(res)and res[0]:
    74.             response = res[0]
    75.         response = response.replace('、',',')
    76. try:
    77. return json.loads(response)
    78. except:
    79. return response
    80.  
    81. definference(sentences: list,
    82.               custom_settings: dict):
    83. """
    84.     推理函数。
    86.     Args:
    87.         sentences (List[str]): 待抽取的句子。
    88.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
    89.     """
    90. for sentence in sentences:
    91.         cls_res ="金融"
    92. if cls_res notin schema:
    93. print(f'The type model inferenced {cls_res} which is not in schema dict, exited.')
    94.             exit()
    95.         properties_str =', '.join(schema[cls_res])
    96.         schema_str_list =f'"{cls_res}"({properties_str})'
    97.         sentence_with_ie_prompt = IE_PATTERN.format(sentence, schema_str_list)
    98. # print(f'sentence_with_prompt-->{sentence_with_ie_prompt}')
    99.         ie_res, history = model.chat(tokenizer,
    100.                                      sentence_with_ie_prompt,
    101.                                      history=custom_settings["ie_pre_history"])
    102.         ie_res = clean_response(ie_res)
    103. print(f'>>> [bold bright_red]sentence: {sentence}')
    104. print(f'>>> [bold bright_green]inference answer:{ie_res} ')
    105.  
    106.  
    107.  
    108. if __name__ =='__main__':
    109. #device = 'cuda:0'
    110.     device ='cpu'
    111.     tokenizer =AutoTokenizer.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",
    112.                                               trust_remote_code=True)
    113. #model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b",
    114. # trust_remote_code=True).half().cuda()
    115.     model =AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",
    116.                                       trust_remote_code=True).float()
    117.     model.to(device)
    118.  
    119.     sentences =[
    120. '2023-02-15，寓意吉祥的节日，股票佰笃[BD]美股开盘价10美元，虽然经历了波动，但最终以13美元收盘，成交量微幅增加至460,000，投资者情绪较为平稳。',
    121. '2023-04-05，市场迎来轻松氛围，股票盘古(0021)开盘价23元，尽管经历了波动，但最终以26美元收盘，成交量缩小至310,000，投资者保持观望态度。',
    122. ]
    123.  
    124.     custom_settings = init_prompts()
    125.  
    126.     inference(
    127.         sentences,
    128.         custom_settings
    129.     )
     

    2.4 文本匹配
     

            文本匹配具体和我之前做的bert是一个项目。这里主要食用prompt实现。和上面基本一致，就不重点阐述了
     

    完整代码如下：
     

    2.4.1 完整代码
     

    1. from rich importprint
    2. from transformers importAutoTokenizer,AutoModel
    3.  
    4. import os
    5.  
    6.  
    7. # 提供相似，不相似的语义匹配例子
    8. examples ={
    9. '是':[
    10. ('公司ABC发布了季度财报，显示盈利增长。','财报披露，公司ABC利润上升。'),
    11. ],
    12. '不是':[
    13. ('黄金价格下跌，投资者抛售。','外汇市场交易额创下新高。'),
    14. ('央行降息，刺激经济增长。','新能源技术的创新。')
    15. ]
    16. }
    17.  
    18. definit_prompts():
    19. """
    20.     初始化前置prompt，便于模型做 incontext learning。
    21.     """
    22.     pre_history =[
    23. (
    24. '现在你需要帮助我完成文本匹配任务，当我给你两个句子时，你需要回答我这两句话语义是否相似。只需要回答是否相似，不要做多余的回答。',
    25. '好的，我将只回答”是“或”不是“。'
    26. )
    27. ]
    28. for key, sentence_pairs in examples.items():
    29. # print(f'key-->{key}')
    30. # print(f'sentence_pairs-->{sentence_pairs}')
    31. for sentence_pair in sentence_pairs:
    32.             sentence1, sentence2 = sentence_pair
    33. # print(f'sentence1-->{sentence1}')
    34. # print(f'sentence2-->{sentence2}')
    35.             pre_history.append((f'句子一:{sentence1}n句子二:{sentence2}n上面两句话是相似的语义吗？',
    36.                                 key))
    37. return{"pre_history": pre_history}
    38.  
    39. definference(
    40.         sentence_pairs: list,
    41.         custom_settings: dict
    42.     ):
    43. """
    44.     推理函数。
    46.     Args:
    47.         model (transformers.AutoModel): Language Model 模型。
    48.         sentence_pairs (List[str]): 待推理的句子对。
    49.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
    50.     """
    51. for sentence_pair in sentence_pairs:
    52.         sentence1, sentence2 = sentence_pair
    53.         sentence_with_prompt =f'句子一: {sentence1}n句子二: {sentence2}n上面两句话是相似的语义吗？'
    54.         response, history = model.chat(tokenizer, sentence_with_prompt, history=custom_settings['pre_history'])
    55. print(f'>>> [bold bright_red]sentence: {sentence_pair}')
    56. print(f'>>> [bold bright_green]inference answer: {response}')
    57. # print(history)
    58.  
    59. if __name__ =='__main__':
    60. #device = 'cuda:0'
    61.     device ='cpu'
    62.     tokenizer =AutoTokenizer.from_pretrained("/Users/ligang/PycharmProjects/llm/ChatGLM-6B/THUDM/chatglm-6b-int4",
    63.                                               trust_remote_code=True)
    64. #model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b",
    65. # trust_remote_code=True).half().cuda()
    66.     model =AutoModel.from_pretrained("/Users/ligang/PycharmProjects/llm/ChatGLM-6B/THUDM/chatglm-6b-int4",
    67.                                       trust_remote_code=True).float()
    68.     model.to(device)
    69.  
    70.     sentence_pairs =[
    71. ('股票市场今日大涨，投资者乐观。','持续上涨的市场让投资者感到满意。'),
    72. ('油价大幅下跌，能源公司面临挑战。','未来智能城市的建设趋势愈发明显。'),
    73. ('利率上升，影响房地产市场。','高利率对房地产有一定冲击。'),
    74. ]
    75.  
    76.     custom_settings = init_prompts()
    77.     inference(
    78.         sentence_pairs,
    79.         custom_settings
    80.     )
     

     
     

    
                    ```"""     # 指令内容，使用 ``` 来分隔指令和待总结的内容
  7. response = get_completion(prompt)
  8. print(response)
  9. # 为了获得所需的输出，您应该提供清晰、具体的指示，避免与简短的提示词混淆，并使用更长的提示
  10. 词来提供更多的清晰度和上下文信息。

b.Producto estructurado

por ejemplo: Generar los títulos, autores y categorías de tres libros y devolverlos en formato JSON. Para facilitar el análisis, especificamos las claves Json: book_id, título, autor, género.

  1. prompt = f"""请生成包括书名、作者和类别的虚构的、非真实存在的中文书籍清单，并以 JSON 格式
  2. 提供，其中包含以下键:book_id、title、author、genre。"""
  3. response = get_completion(prompt)
  4. print(response)
  5. [
  6. { "book_id": 1, "title": "幻境之夜", "author": "李梦飞", "genre": "奇幻小说"
  7. },
  8. ... ]

c. Ejemplo de referencia

         Consejos de disparo cero:El modelo solo genera respuestas basadas en la descripción de la tarea y no requiere ningún ejemplo.

         Consejos únicos:Sólo se proporciona un ejemplo.

Consejos para pocas tomas: Proporcione algunos ejemplos. La función de las indicaciones es guiar al modelo para que aprenda y realice tareas específicas a través de una pequeña cantidad de muestras. Por ejemplo, al proporcionar una pequeña cantidad de ejemplos de estilos o temas, guía al modelo para producir creaciones con estilos o temas similares.

d.Dejar que el modelo actúe como un papel.

Ejemplo : Por favor explique "Ser o no ser, esa es la cuestión" como Hamlet de la obra de Shakespeare. Este ejemplo requiere que el modelo interprete la famosa pregunta "ser o no ser" utilizando el papel del protagonista de la obra de Shakespeare "Hamlet" para demostrar el desempeño y la comprensión contextual del modelo en diferentes roles.

2. Modelar el combate real

Tareas del proyecto(Tres escenarios comerciales principales):

1. Clasificación de textos

2. Extracción de información de texto

3.Coincidencia de texto

Gran selección de modelos：ChatGLM-6B

métodos de adaptación: Basado en las ideas de Few-Shot + Zero-Shot e Instrunction, diseñe el mensaje y luego aplique el modelo ChatGLM-6B para completar las tareas correspondientes.

2.1 Preparación

a. Usamos el entorno Python para ejecutar modelos grandes, por lo que primero debemos descargar Python (se recomienda Anaconda).

b Descargue el modelo ChatGLM-6B, el enlace es el siguiente:

https://github.com/THUDM/ChatGLM-6B?tab=readme-ov-file

El modelo ChatGLM-6B y los requisitos de hardware se presentan en el archivo README.

Nivel cuantitativoMemoria mínima de GPU(razonamiento)Memoria mínima de GPU(Ajuste eficiente de parámetros)
FP16 (sin cuantificación)13 GB14 GB
INT88 GB9 GB
INT46 GB7 GB

c. Instale las dependencias requeridas en su anaconda. En el paquete descargado anteriormente de github, en realidad coloca todas las dependencias requeridas en requisitos.txt, ingréselo directamente:

pip install -r requisitos.txt

Si la velocidad de descarga es muy lenta, agregue el espejo Tsinghua

pip install -r requisitos.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

entransformersLa versión de biblioteca recomendada es4.27.1, pero teóricamente nada menos que4.23.1Eso es todo.

Además, si necesita ejecutar el modelo cuantificado en la CPU, también necesita instalargccyopenmp . La mayoría de las distribuciones de Linux lo tienen instalado por defecto. entorno de prueba de WindowsgccLa versión esTDM-GCC 10.3.0, Linux esgcc 11.3.0。

d. Cargue el modelo desde local:

El código anterior será generado portransformers Descargue automáticamente la implementación y los parámetros del modelo. La implementación completa del modelo se puede encontrar en Hugging Face Hub. Si su entorno de red es deficiente, la descarga de los parámetros del modelo puede tardar mucho tiempo o incluso fallar. En este momento, primero puede descargar el modelo al local y luego cargarlo desde el local.

Para descargar el modelo de Hugging Face Hub, primero debe instalar Git LFS y luego ejecutar

git clone https://huggingface.co/THUDM/chatglm-6b

Si tarda en descargar el punto de control de Hugging Face Hub, solo puede descargar la implementación del modelo.

GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/THUDM/chatglm-6b

Luego descargue manualmente el archivo de parámetros del modelo desde aquí y reemplace el archivo descargado al localchatglm-6bBajo contenidos.

Después de descargar el modelo localmente, cambie elTHUDM/chatglm-6bReemplace con su localchatglm-6bLa ruta a la carpeta para cargar el modelo localmente.

Atención MAC

Mac carga directamente el modelo cuantificado y aparece el mensaje `clang: error: opción no admitida '-fopenmp'.

Esto se debe a la falta de omp en la propia Mac, que puede ejecutarse en este momento pero es de un solo núcleo. Debe instalar la dependencia de openmp por separado para usar OMP en Mac:

  1. # 参考`https://mac.r-project.org/openmp/`
  2. ## 假设: gcc(clang)是14.x版本，其他版本见R-Project提供的表格
  3. curl -O https://mac.r-project.org/openmp/openmp-14.0.6-darwin20-Release.tar.gz
  4. sudo tar fvxz openmp-14.0.6-darwin20-Release.tar.gz -C /

Los siguientes archivos se instalarán en este momento:/usr/local/lib/libomp.dylib, /usr/local/include/ompt.h, /usr/local/include/omp.h, /usr/local/include/omp-tools.h。

NOTA: Si ejecutó anteriormenteChatGLMSi el proyecto falla, es mejor borrar el caché de Huggingface. La configuración predeterminada para IE es.rm -rf ${HOME}/.cache/huggingface/modules/transformers_modules/chatglm-6b-int4 .debido al usormcomando, sepa exactamente lo que está eliminando.

Esta es la solución oficial, pero no tuve éxito. Agregué lo siguiente al código:

  1. import os
  2. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

Errores de ejecución de mac evitados.

2.2 Clasificación de texto

Nuestro propósito es esperar que el modelo pueda ayudarnos a identificar qué tipo de informe describe cada oración en estos cuatro párrafos.

  1. sentences = [
  2.         "今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。",
  3.         "ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。",
  4.         "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",

Para modelos grandes, el diseño de indicaciones es muy importante. Una indicación clara puede ayudarnos a obtener mejor los resultados que queremos de los modelos grandes.

En el diseño puntual de esta tarea, consideramos principalmente dos puntos:

1. Debe explicarle al modelo qué es una "tarea de clasificación de texto".

2. El modelo debe generarse en el formato que especifiquemos.

2.2.1 Importar paquete
  1. """
  2. 利用 LLM 进行文本分类任务。
  3. """
  4. from rich import print
  5. from rich.console import Console
  6. from transformers import AutoTokenizer, AutoModel
  7. import os
  8. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
2.2.2 Definir la función init_prompts
  1. # 提供所有类别以及每个类别下的样例
  2. class_examples ={
  3. '新闻报道':'今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。',
  4. '财务报告':'本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。',
  5. '公司公告':'本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力',
  6. '分析师报告':'最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势'}
  7.  
  8. # 定义init_prompts函数
  9. definit_prompts():
  10. '''
  11.     这里是对函数的功能进行注释，方便他人理解：该函数的目的是初始化前置prompt,便于模型做Few-shot
  12.     :return: dict字典
  13.     '''
  14.     class_list =list(class_examples.keys())
  15. print(f'分类的类别数：{class_list}')
  16.  
  17.     pre_history =[
  18. (f'现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：{class_list}类别中。',
  19. f'好的。')
  20. ]
  21. # 遍历给的示例样本
  22. for _type, example in class_examples.items():
  23. # print(f'键--》{_type}')
  24. # print(f'值--》{example}')
  25.         pre_history.append((f'"{example}"是{class_list}里的什么类别', _type))
  26.  
  27. # print(f'pre_history--》{pre_history}')
  28. return{"class_list":class_list,"pre_history":pre_history}

a. Proporcione un ejemplo de algunas tomas y marque las palabras correspondientes a cada categoría.

b. Almacenar la categoría en class_list

c. Dar una indicación antes de proporcionar la muestra. Es decir, díselo al modelo. Eres un clasificador de texto, ¿qué quieres hacer exactamente? y dar una respuesta (separada por comas). (equivalente a una formación supervisada)

d. Recorra los ejemplos dados y agréguelos a pre_history.

e. Devolver un diccionario.

Los resultados impresos son los siguientes:

  1. 分类的类别数：['新闻报道','财务报告','公司公告','分析师报告']
  2. 键--》新闻报道
  3. 值--》今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。
  4. 键--》财务报告
  5. 值--》本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。
  6. 键--》公司公告
  7. 值--》本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力
  8. 键--》分析师报告
  9. 值--》最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势
  10. pre_history--》[("现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：['新闻报道', '财务报告', '公司公告', '分析师报告']类别中。",'好的。'),('"今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','新闻报道'),('"本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','财务报告'),('"本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','公司公告'),('"最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势"是['新闻报道', '财务报告', '公司公告', '分析师报告']里的什么类别','分析师报告')]
2.2.3 Definir la función de inferencia
  1.     sentences = [
  2. "今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。",
  3. "ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。",
  4. "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
  5. "最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会",
  6. ]
  7.  
  8. definference(sentences: list,
  9.               custom_settings: dict):
  10. """
  11.     推理函数。
  13.     Args:
  14.         sentences (List[str]): 待推理的句子。
  15.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
  16.     """
  17. for sentence in sentences:
  18. #没啥含义，就是改变打印的颜色。
  19. with console.status("[bold bright_green] Model Inference..."):
  20. #
  21.             sentence_prompt =f'"{sentence}"是{custom_settings["class_list"]}里的什么类别？'
  22.             response, history = model.chat(tokenizer, sentence_prompt, history=custom_settings['pre_history'])
  23. print(f'>>>[bold bright_red]sentence:{sentence}')
  24. print(f'>>>[bold bright_green]inference answer:{response}')
  25. print(f'history-->{history}')
  26. print("*"*80)

ingresar：

1. Oraciones: Oraciones sobre las que se debe razonar.

2. custom_settings: proyecto rápido preparado por init_prompts.

proceso:

1. Recorre las frases que requieren razonamiento.

2. Ejecute el código central model.chat(tokenizer, frase_prompt, historial=custom_settings['pre_history'])

en:

Tokenizer: Es el tokenizador del código (puede entenderse como la unidad más pequeña de una palabra)

Sentencia_prompt: complementa la oración de la pregunta en un mensaje completo.

historia: declaraciones históricas previamente preparadas

Resultados impresos:

  1. >>>sentence:今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。
  2. >>>inference answer:新闻报道
  3. >>>sentence:ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩
  4. 固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。
  5. >>>inference answer:公司公告
  6. ********************************************************************************
  7. >>>sentence:公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。
  8. >>>inference answer:财务报告
  9. ********************************************************************************
  10. >>>sentence:最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会
  11. >>>inference answer:分析师报告

Puedes ver que la clasificación fue exitosa. En este momento, tengo una idea audaz. ¿Qué pasa si escribo una oración que no tiene nada que ver con ninguna de las categorías?

sentences = ["我今天中午和朋友吃了牛肉粉丝汤，不小心洒了一地"]

Se imprimirá como: Informe de noticias

En este momento solo agrega:

  1. "现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：['新闻
  2. 报道', '财务报告', '公司公告', '分析师报告']类别中。如果都不是就输出：'其他' ",

El resultado puede ser:

  1. >>>sentence:我今天中午和朋友吃了牛肉粉丝汤，不小心洒了一地
  2. >>>inference answer:其他
2.2.4 Código completo
  1. # —*-coding:utf-8-*-
  2. """
  3. 利用 LLM 进行文本分类任务。
  4. """
  5. from rich importprint
  6. from rich.console importConsole
  7. from transformers importAutoTokenizer,AutoModel
  8. import os
  9. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
  10.  
  11.  
  12. # 提供所有类别以及每个类别下的样例
  13. class_examples ={
  14. '新闻报道':'今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。',
  15. '财务报告':'本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。',
  16. '公司公告':'本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力',
  17. '分析师报告':'最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势'}
  18.  
  19. # 定义init_prompts函数
  20. definit_prompts():
  21. '''
  22.     这里是对函数的功能进行注释，方便他人理解：该函数的目的是初始化前置prompt,便于模型做Few-shot
  23.     :return: dict字典
  24.     '''
  25.     class_list =list(class_examples.keys())
  26. print(f'分类的类别数：{class_list}')
  27.  
  28.     pre_history =[
  29. (f'现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：{class_list}类别中。',
  30. f'好的。')
  31. ]
  32. # 遍历给的示例样本
  33. for _type, example in class_examples.items():
  34. # print(f'键--》{_type}')
  35. # print(f'值--》{example}')
  36.         pre_history.append((f'"{example}"是{class_list}里的什么类别', _type))
  37.  
  38. # print(f'pre_history--》{pre_history}')
  39. return{"class_list":class_list,"pre_history":pre_history}
  40.  
  41. definference(sentences: list,
  42.               custom_settings: dict):
  43. """
  44.     推理函数。
  46.     Args:
  47.         sentences (List[str]): 待推理的句子。
  48.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
  49.     """
  50. for sentence in sentences:
  51. with console.status("[bold bright_green] Model Inference..."):
  52.             sentence_prompt =f'"{sentence}"是{custom_settings["class_list"]}里的什么类别？'
  53.             response, history = model.chat(tokenizer, sentence_prompt, history=custom_settings['pre_history'])
  54. print(f'>>>[bold bright_red]sentence:{sentence}')
  55. print(f'>>>[bold bright_green]inference answer:{response}')
  56. print(f'history-->{history}')
  57. print("*"*80)
  58.  
  59.  
  60. if __name__ =='__main__':
  61.     console =Console()
  62. #device = 'cuda:0'
  63.     device ='cpu'
  64.     tokenizer =AutoTokenizer.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",trust_remote_code=True)
  65. # model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b", trust_remote_code=True).half().cuda()
  66.     model =AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",trust_remote_code=True).float()
  67.     model.to(device)
  68.  
  69. # sentences = [
  70. #     "今天，央行决定通过降低利率来刺激经济增长。这一决策预计会影响到贷款利率，并在接下来的几个季度对金融市场产生深远影响。",
  71. #     "ABC公司今日宣布，他们已成功收购了XYZ公司的股权。这一重要的收购交易有助于ABC公司扩展业务范围，增强市场竞争力。据悉，这次收购将进一步巩固ABC公司在行业中的地位，并为未来的业务发展提供更广阔的空间。详细信息请参阅公司官方网站公告栏。",
  72. #     "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
  73. #     "最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会",
  74. #     ]
  75. # sentences = ["金融系统是建设金融强国责无旁贷的主力军，必须切实把思想和行动统一到党中央决策部署上来，深刻把握建设金融强国的精髓要义和实践要求，不断增强使命感、责任感，推动宏伟蓝图一步步变成美好现实"]
  76.     sentences =["我今天中午和朋友吃了牛肉粉丝汤，不小心洒了一地"]
  77.     custom_settings = init_prompts()
  78. print(custom_settings)
  79.  
  80.     inference(
  81.         sentences,
  82.         custom_settings
  83.     )

La función principal llama principalmente al tokenizador y al modelo utilizados esta vez.

Aviso：

Si selecciona el modelo chatglm-6b-int4 durante la ejecución en una Mac, se informará un error.

  1.     logger.warning("Failed to load cpm_kernels:", exception)
  2. Message: 'Failed to load cpm_kernels:'
  3. Arguments: (RuntimeError('Unknown platform: darwin'),)

Si aún se puede ejecutar, no se preocupe. Si no funciona, simplemente cambie al modelo chatglm-6b.

Si desea utilizar gpu para ejecutar el modelo, puede reemplazarlo con este código

# model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b", trust_remote_code=True).half().cuda()

2.3 Extracción de información de texto

De hecho, la extracción de información de texto también es consistente. Lo principal es implementar la función init_prompts y la función de inferencia.

2.3.1 Implementar la función init_prompts
  1. import re
  2. import json
  3.  
  4.  
  5. from rich importprint
  6. from transformers importAutoTokenizer,AutoModel
  7. import os
  8. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
  9.  
  10. # 定义不同实体下的具备属性
  11. schema ={
  12. '金融':['日期','股票名称','开盘价','收盘价','成交量'],
  13. }
  14.  
  15. # 信息抽取的模版
  16. IE_PATTERN ="{}nn提取上述句子中{}的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表示，多个值之间用','分隔。"
  17.  
  18.  
  19. # 提供一些例子供模型参考
  20. ie_examples ={
  21. '金融':[
  22. {
  23. 'content':'2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元，随后回落至98美元，最终以102美元收盘，成交量达到520000。',
  24. 'answers':{
  25. '日期':['2023-01-10'],
  26. '股票名称':['古哥-D[EOOE]美股'],
  27. '开盘价':['100美元'],
  28. '收盘价':['102美元'],
  29. '成交量':['520000'],
  30. }
  31. }
  32. ]
  33. }
  34.  
  35.  
  36. # 定义init_prompts函数
  37. definit_prompts():
  38. """
  39.      初始化前置prompt，便于模型做 incontext learning。
  40.      """
  41.     ie_pre_history =[
  42. (
  43. "现在你需要帮助我完成信息抽取任务，当我给你一个句子时，你需要帮我抽取出句子中实体信息，并按照JSON的格式输出，上述句子中没有的信息用['原文中未提及']来表示，多个值之间用','分隔。",
  44. '好的，请输入您的句子。'
  45. )
  46. ]
  47. for _type, example_list in ie_examples.items():
  48. print(f'_type-->{_type}')
  49. print(f'example_list-->{example_list}')
  50. print(f'*'*80)
  51. for example in example_list:
  52.             sentence = example["content"]
  53.             properties_str =', '.join(schema[_type])
  54. print(f'properties_str-->{properties_str}')
  55.             schema_str_list =f'"{_type}"({properties_str})'
  56. print(f'schema_str_list-->{schema_str_list}')
  57.  
  58.             sentence_with_prompt = IE_PATTERN.format(sentence, schema_str_list)
  59. print(f'sentence_with_prompt-->{sentence_with_prompt}')
  60.             ie_pre_history.append((f"{sentence_with_prompt}",f"{json.dumps(example['answers'], ensure_ascii=False)}"))
  61. print(f'ie_pre_history-->{ie_pre_history}')
  62.  
  63. return{"ie_pre_history":ie_pre_history}
  64.  
  65. init_prompts()

a. Proporcione un ejemplo breve para definir atributos en diferentes entidades.

b. Complete el mensaje

c. Agregar a ie_pre_history

Imprima de la siguiente manera:

  1. _type-->金融
  2. example_list-->[{'content':
  3. '2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元
  4. ，随后回落至98美元，最终以102美元收盘，成交量达到520000。','answers':{'日期':
  5. ['2023-01-10'],'股票名称':['古哥-D[EOOE]美股'],'开盘价':['100美元'],
  6. '收盘价':['102美元'],'成交量':['520000']}}]
  7. ********************************************************************************
  8. properties_str-->日期,股票名称,开盘价,收盘价,成交量
  9. schema_str_list-->"金融"(日期,股票名称,开盘价,收盘价,成交量)
  10. sentence_with_prompt-->2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美
  11. 元，一度飙升至105美元，随后回落至98美元，最终以102美元收盘，成交量达到520000。
  12.  
  13. 提取上述句子中"金融"(日期,股票名称,开盘价,收盘价,
  14. 成交量)的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表
  15. 示，多个值之间用','分隔。
  16. ie_pre_history-->[("现在你需要帮助我完成信息抽取任务，当我给你一个句子时，你需要
  17. 帮我抽取出句子中实体信息，并按照JSON的格式输出，上述句子中没有的信息用['原文中未
  18. 提及']来表示，多个值之间用','分隔。",'好的，请输入您的句子。'),
  19. ('2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元
  20. ，随后回落至98美元，最终以102美元收盘，成交量达到520000。nn提取上述句子中"金融
  21. "(日期, 股票名称, 开盘价, 收盘价, 
  22. 成交量)的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来
  23. 表示，多个值之间用','分隔。','{"日期": ["2023-01-10"], "股票名称": 
  24. ["古哥-D[EOOE]美股"], "开盘价": ["100美元"], "收盘价": ["102美元"], "成交量": 
  25. ["520000"]}')]
2.3.2 Definir la función de inferencia
  1. def inference(sentences: list,
  2.               custom_settings: dict):
  3. """
  4.     推理函数。
  6.     Args:
  7.         sentences (List[str]): 待抽取的句子。
  8.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
  9.     """
  10. for sentence in sentences:
  11.         cls_res ="金融"
  12. if cls_res notin schema:
  13. print(f'The type model inferenced {cls_res} which is not in schema dict, exited.')
  14.             exit()
  15.         properties_str =', '.join(schema[cls_res])
  16.         schema_str_list =f'"{cls_res}"({properties_str})'
  17.         sentence_with_ie_prompt = IE_PATTERN.format(sentence, schema_str_list)
  18. # print(f'sentence_with_prompt-->{sentence_with_ie_prompt}')
  19.         ie_res, history = model.chat(tokenizer,
  20.                                      sentence_with_ie_prompt,
  21.                                      history=custom_settings["ie_pre_history"])
  22.         ie_res = clean_response(ie_res)
  23. print(f'>>> [bold bright_red]sentence: {sentence}')
  24. print(f'>>> [bold bright_green]inference answer:{ie_res} ')

a. Definir entrada:

oraciones (List[str]): Oraciones a extraer. custom_settings (dict): configuraciones iniciales, incluidos ejemplos de pocas tomas dados artificialmente.

b. Definir categoría: cls_res = "Finanzas"

Las categorías están escritas aquí. Si hay varias categorías. Primero puede implementar la clasificación de texto y luego extraer información de texto.

c. Complete las oraciones ingresadas y llame a model.chat

d. Realice un posprocesamiento de los resultados del modelo, extraiga el modelo json y envíelo.

Imprima de la siguiente manera:

  1. >>> sentence: 
  2. 2023-02-15，寓意吉祥的节日，股票佰笃[BD]美股开盘价10美元，虽然经历了波动，但最终
  3. 以13美元收盘，成交量微幅增加至460,000，投资者情绪较为平稳。
  4. >>> inference answer:{'日期': ['2023-02-15'], '股票名称': ['佰笃[BD]美股'], 
  5. '开盘价': ['10美元'], '收盘价': ['13美元'], '成交量': ['460,000']}
2.3.3 Código completo
  1. import re
  2. import json
  3.  
  4.  
  5. from rich importprint
  6. from transformers importAutoTokenizer,AutoModel
  7. import os
  8. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
  9.  
  10. # 定义不同实体下的具备属性
  11. schema ={
  12. '金融':['日期','股票名称','开盘价','收盘价','成交量'],
  13. }
  14.  
  15. # 信息抽取的模版
  16. IE_PATTERN ="{}nn提取上述句子中{}的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表示，多个值之间用','分隔。"
  17.  
  18.  
  19. # 提供一些例子供模型参考
  20. ie_examples ={
  21. '金融':[
  22. {
  23. 'content':'2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元，随后回落至98美元，最终以102美元收盘，成交量达到520000。',
  24. 'answers':{
  25. '日期':['2023-01-10'],
  26. '股票名称':['古哥-D[EOOE]美股'],
  27. '开盘价':['100美元'],
  28. '收盘价':['102美元'],
  29. '成交量':['520000'],
  30. }
  31. }
  32. ]
  33. }
  34.  
  35. # 定义init_prompts函数
  36. definit_prompts():
  37. """
  38.      初始化前置prompt，便于模型做 incontext learning。
  39.      """
  40.     ie_pre_history =[
  41. (
  42. "现在你需要帮助我完成信息抽取任务，当我给你一个句子时，你需要帮我抽取出句子中实体信息，并按照JSON的格式输出，上述句子中没有的信息用['原文中未提及']来表示，多个值之间用','分隔。",
  43. '好的，请输入您的句子。'
  44. )
  45. ]
  46. for _type, example_list in ie_examples.items():
  47. # print(f'_type-->{_type}')
  48. # print(f'example_list-->{example_list}')
  49. # print(f'*'*80)
  50. for example in example_list:
  51.             sentence = example["content"]
  52.             properties_str =', '.join(schema[_type])
  53. # print(f'properties_str-->{properties_str}')
  54.             schema_str_list =f'"{_type}"({properties_str})'
  55. # print(f'schema_str_list-->{schema_str_list}')
  56.  
  57.             sentence_with_prompt = IE_PATTERN.format(sentence, schema_str_list)
  58. print(f'sentence_with_prompt-->{sentence_with_prompt}')
  59.             ie_pre_history.append((f"{sentence_with_prompt}",f"{json.dumps(example['answers'], ensure_ascii=False)}"))
  60. print(f'ie_pre_history-->{ie_pre_history}')
  61.  
  62. return{"ie_pre_history":ie_pre_history}
  63.  
  64. defclean_response(response: str):
  65. """
  66.     后处理模型输出。
  68.     Args:
  69.         response (str): _description_
  70.     """
  71. if'```json'in response:
  72.         res = re.findall(r'```json(.*?)```', response)
  73. iflen(res)and res[0]:
  74.             response = res[0]
  75.         response = response.replace('、',',')
  76. try:
  77. return json.loads(response)
  78. except:
  79. return response
  80.  
  81. definference(sentences: list,
  82.               custom_settings: dict):
  83. """
  84.     推理函数。
  86.     Args:
  87.         sentences (List[str]): 待抽取的句子。
  88.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
  89.     """
  90. for sentence in sentences:
  91.         cls_res ="金融"
  92. if cls_res notin schema:
  93. print(f'The type model inferenced {cls_res} which is not in schema dict, exited.')
  94.             exit()
  95.         properties_str =', '.join(schema[cls_res])
  96.         schema_str_list =f'"{cls_res}"({properties_str})'
  97.         sentence_with_ie_prompt = IE_PATTERN.format(sentence, schema_str_list)
  98. # print(f'sentence_with_prompt-->{sentence_with_ie_prompt}')
  99.         ie_res, history = model.chat(tokenizer,
  100.                                      sentence_with_ie_prompt,
  101.                                      history=custom_settings["ie_pre_history"])
  102.         ie_res = clean_response(ie_res)
  103. print(f'>>> [bold bright_red]sentence: {sentence}')
  104. print(f'>>> [bold bright_green]inference answer:{ie_res} ')
  105.  
  106.  
  107.  
  108. if __name__ =='__main__':
  109. #device = 'cuda:0'
  110.     device ='cpu'
  111.     tokenizer =AutoTokenizer.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",
  112.                                               trust_remote_code=True)
  113. #model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b",
  114. # trust_remote_code=True).half().cuda()
  115.     model =AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b-int4",
  116.                                       trust_remote_code=True).float()
  117.     model.to(device)
  118.  
  119.     sentences =[
  120. '2023-02-15，寓意吉祥的节日，股票佰笃[BD]美股开盘价10美元，虽然经历了波动，但最终以13美元收盘，成交量微幅增加至460,000，投资者情绪较为平稳。',
  121. '2023-04-05，市场迎来轻松氛围，股票盘古(0021)开盘价23元，尽管经历了波动，但最终以26美元收盘，成交量缩小至310,000，投资者保持观望态度。',
  122. ]
  123.  
  124.     custom_settings = init_prompts()
  125.  
  126.     inference(
  127.         sentences,
  128.         custom_settings
  129.     )

2.4 Coincidencia de texto

La coincidencia de texto es específicamente un proyecto con el bert que hice antes. Aquí utilizamos principalmente una implementación rápida.Es básicamente lo mismo que el anterior, por lo que no me centraré en la elaboración.

El código completo es el siguiente:

2.4.1 Código completo
  1. from rich importprint
  2. from transformers importAutoTokenizer,AutoModel
  3.  
  4. import os
  5.  
  6.  
  7. # 提供相似，不相似的语义匹配例子
  8. examples ={
  9. '是':[
  10. ('公司ABC发布了季度财报，显示盈利增长。','财报披露，公司ABC利润上升。'),
  11. ],
  12. '不是':[
  13. ('黄金价格下跌，投资者抛售。','外汇市场交易额创下新高。'),
  14. ('央行降息，刺激经济增长。','新能源技术的创新。')
  15. ]
  16. }
  17.  
  18. definit_prompts():
  19. """
  20.     初始化前置prompt，便于模型做 incontext learning。
  21.     """
  22.     pre_history =[
  23. (
  24. '现在你需要帮助我完成文本匹配任务，当我给你两个句子时，你需要回答我这两句话语义是否相似。只需要回答是否相似，不要做多余的回答。',
  25. '好的，我将只回答”是“或”不是“。'
  26. )
  27. ]
  28. for key, sentence_pairs in examples.items():
  29. # print(f'key-->{key}')
  30. # print(f'sentence_pairs-->{sentence_pairs}')
  31. for sentence_pair in sentence_pairs:
  32.             sentence1, sentence2 = sentence_pair
  33. # print(f'sentence1-->{sentence1}')
  34. # print(f'sentence2-->{sentence2}')
  35.             pre_history.append((f'句子一:{sentence1}n句子二:{sentence2}n上面两句话是相似的语义吗？',
  36.                                 key))
  37. return{"pre_history": pre_history}
  38.  
  39. definference(
  40.         sentence_pairs: list,
  41.         custom_settings: dict
  42.     ):
  43. """
  44.     推理函数。
  46.     Args:
  47.         model (transformers.AutoModel): Language Model 模型。
  48.         sentence_pairs (List[str]): 待推理的句子对。
  49.         custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
  50.     """
  51. for sentence_pair in sentence_pairs:
  52.         sentence1, sentence2 = sentence_pair
  53.         sentence_with_prompt =f'句子一: {sentence1}n句子二: {sentence2}n上面两句话是相似的语义吗？'
  54.         response, history = model.chat(tokenizer, sentence_with_prompt, history=custom_settings['pre_history'])
  55. print(f'>>> [bold bright_red]sentence: {sentence_pair}')
  56. print(f'>>> [bold bright_green]inference answer: {response}')
  57. # print(history)
  58.  
  59. if __name__ =='__main__':
  60. #device = 'cuda:0'
  61.     device ='cpu'
  62.     tokenizer =AutoTokenizer.from_pretrained("/Users/ligang/PycharmProjects/llm/ChatGLM-6B/THUDM/chatglm-6b-int4",
  63.                                               trust_remote_code=True)
  64. #model = AutoModel.from_pretrained("./ChatGLM-6B/THUDM/chatglm-6b",
  65. # trust_remote_code=True).half().cuda()
  66.     model =AutoModel.from_pretrained("/Users/ligang/PycharmProjects/llm/ChatGLM-6B/THUDM/chatglm-6b-int4",
  67.                                       trust_remote_code=True).float()
  68.     model.to(device)
  69.  
  70.     sentence_pairs =[
  71. ('股票市场今日大涨，投资者乐观。','持续上涨的市场让投资者感到满意。'),
  72. ('油价大幅下跌，能源公司面临挑战。','未来智能城市的建设趋势愈发明显。'),
  73. ('利率上升，影响房地产市场。','高利率对房地产有一定冲击。'),
  74. ]
  75.  
  76.     custom_settings = init_prompts()
  77.     inference(
  78.         sentence_pairs,
  79.         custom_settings
  80.     )

 

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo