微调笔记

分类：

fine tuning 传统全量微调，（高质量微调）

prompt tuning（提示词微调）

​ 技术：指令微调

​ 上下文学习

​ chain of thought（思维链）

PET模型（Pattern-Exploiting Training）

POFT方法：分成三种类型：（面向提示的微调）

• 全量微调（Full Fine-Tuning）：模型所有参数都参与更新，包括预训练模型参数和下游任务层参数。如PET模型。
• 部分参数微调（Partial Fine-Tuning）：只更新预训练模型中的一部分参数，比如高层 transformer block、某些 attention 层或特定模块，其余参数冻结。如Adapter Tuning。
• 仅提示参数微调（Prompt-Only Tuning）：冻结原始预训练模型参数，只训练 prompt 参数。如P-tuning、Prompt Tuning等。

Soft Prompt及微调方法

PEFT(参数高效微调)

conda env export > /ptune_chatglm/execute_successful_requir.txt

autodl-tmp/llm_tuning/ptune_chatglm

LoRA

三元组提取（基于用户的输入prompt，送给大模型，做实体提取预测。）

文本分类

问题：

请基于这个html文件，告诉我这是什么任务，基于用户评论的情感分类吗?

lora_rank中lora的每个单词是什么意思

THUDM是什么意思？是组合缩略词吗？拆解开来是哪些单词组成的。合起来是什么意思。尤其在代码中是什么意思？

done

谷歌浏览器的添加网页功能很单一，加到一定数量之后，一些网址就隐藏到可视列表之下了，需要滚轮向下翻。我想知道如何把这些添加的网页管理起来，把相似的网页，放到同一个目录下。

请基于上传的两个html文件，告诉我data_process.py文件中，读取的数据

请告诉我在json文件中 \n和\n\n符号的区别？

{“context”: “Instruction: 你现在是一个很厉害的阅读理解器，严格按照人类指令进行回答。\nInput: 句子中包含了哪些信息，输出json：\n\n江立，男，瑶族，1978年1月出生，广西恭城人。\nAnswer: “, “target”: “json\n[{\"predicate\": \"出生日期\", \"object_type\": \"Date\", \"subject_type\": \"人物\", \"object\": \"1978年1月\", \"subject\": \"江立\"}, {\"predicate\": \"民族\", \"object_type\": \"Text\", \"subject_type\": \"人物\", \"object\": \"瑶族\", \"subject\": \"江立\"}, {\"predicate\": \"出生地\", \"object_type\": \"地点\", \"subject_type\": \"人物\", \"object\": \"广西恭城\", \"subject\": \"江立\"}]\n“}

上述句子中句尾\n后的三撇是什么符号？

pandoc “D:\software\fine_tuning\01_课件\site\01-大模型微调主要方式\01-大模型Prompt-Tuning方法.html” -f html -t markdown –wrap=preserve -o “C:\Users\gan\Desktop\输出文件.md”

批量转换（在 PowerShell 中）：
打开 PowerShell，导航到你的 HTML 文件所在的文件夹，然后运行：

powershell

复制

下载

1

Get-ChildItem *.html | ForEach-Object { pandoc $_.Name -f html -t markdown -o ($_.BaseName + ".md") }

1

nvidia-smi 查看cuda版本号

RAG流程：

mysql储存FQA高频问答对数据

问题检索：BM25

连接数据库

添加表（带着字段）

添加数据

json.dumps()

mysql 存储自己的网址和密码。（自己设计一个RAG系统）

声明回退问题，把原来的复杂查询简化，第一个query检索

进行改写。主题含义不变。

milvus可以处理的数据集的大小限制是多少

技术实现：

增强索引：设计目标、核心功能、技术实现

多粒度切块，把块-分子块，对应的父块，提供给LLM

文档切成一块，存储milvus中的文档，

query是为题，编程向量，

太长的拆成四个

128个向量

父块是一个

子块分成子块去做检索

切块的子块数都是超参数

混合检索：BM25，向量检索，字符检索

base：基础模块，配置、日志

core：核心逻辑模块，实现RAG的关键功能

main：系统运行入口，支持数据处理和交互查询

中午将一份唯二

通用知识由大语言模型回答，

直接 hyde 子查询 会输

文档检索：支持抽向量和系数向量的混合检索，

中午，下午

语义关键字，倒排（关键字检索

两句话的相似性，

混合检索，重排序优化，

作为回答送给大模型，方便理解。

用户查询

代码目录结构：

配置管理、日志记录

config。py

最大支持customer service phone

fallback

document_process

langchain的文档加载器

markdowm text splitter

datetime import datetime

相对路径（三方包）

模型切分工具、

文档加载器的类（处理pdf、word、ppt、图片

OCR可以提取图像里的内容

optical character recognition光学字符识别

paddle paddle ocr的工具库，基于深度学习技术，

可以把图像中的文字提取出来。

pdf 中的图片，怎么解决？paddle OCR；只能识别简单的图片rapid OCR

cv2：

寻味羊*村超BA之苗侗味道（第一档口华兴美食城店）

docx第三方库

迭代器

读取ppt的内容OCRIMGLoader（file path）

添加源数据，direcotry_path

documents 所有的键

扩展名集合

source

RAG-Langchain

RAG

解决什么问题：

信息过时：网络检索，获取最新数据

领域知识缺失：微调，将专有和私有的知识放到知识库里

幻觉：RAG（retrieval augmented generate），减轻幻觉，基于相关文档进行生成，

安全：RAG,无需将数据送到公开大模型中训练，放到本地知识库，使用本地的模型（api会泄露）进行调用，避免数据的公开和泄露。2）私有数据时存在本地知识库的，做一个权限的管控。

RAG定义：检索技术+生成（LLM提示）

处理流程：构建索引（文件加载、内容读取、chunk构建（拆成小文件，小块）、向量化（小块文档向量化）、落向量化

检索：query向量化，找到topk

生成：topk+query构建prompt；llm生成。

开发框架：LLaMAIndex、Langchain（快速搭建大模型）

Langchain

langchain将模型分为三种（

langchian是用于构建大模型应用程序的框架，帮助开发者更高效的组合和使用多语言的工具。

原始大模型：LLM、chat models、embeddings

chain：组装chain：chain=LLMChain（llm=model,prompt=prompt_template)

output_parsers

字符串解析器、列表解析器、json解析器、定义类、自定义解析器

根据实际情况，调用api，做规范化

字符串解析器：提取模型返回的原始文本

1
2
3
4
5
6
7
8
9

创建简单链
创建字符串解析器
stroutputparser()
组合组件
prompt|model
调用链
result=chain.invoke()
将字符串解析器添加到链中

列表解析器：文本转换为列表

parser.get format instructions 创建带格式说明的提示模版

1
2
3

创建列表解析器
创建提示模版，包含列表解析器的格式说明，也就是你要告诉模型输出的格式，然后大模型会按照这个输出结果

Json解析器

1
2
3

创建带格式说明的提示模版
json.parse.geet_format_instructions()
Chatprompttemplate.from_template()

Pydantic解析器：python库，用于数据验证

1
2
3
4
5

定义pydantic模型
创建pydantic解析器
创建带格式说明的提示模版
组合组件
调用链

自定义解析器（输出格式非常复杂情况下，就自定义格式进行输出）

1
2
3
4
5
6
7
8

需要继承baseoutputparser，实现parse（）方法，get format instructions（）方法
解析大模型的输出，然后组织成想要的个数
提供格式指导给模型
处理空白和换行符，用冒号做split切分；返回一个字典
custom，
定义大模型输出的格式
from template（模版说明）

解析器：告诉大模型该怎么输出 get_fromat_instructions()

invoke(填充好提示词)，最后通过结果解析器，调用parse方法

核心是实现parse方法。

Memory

储存上下文，储存历史

langchain提供了memory组件：

ChatMessageHistory:只是简单存储

1
2
3
4
5
6

history = ChatMessageHistory（）
添加用户消息
history.add_user_message('xxx')
添加大模型回复的消息
history.add_ai_message('xxx')

ConversationChain：

创建一个对象，放一个llm=llm参数

1
2
3
4
5
6
7
8
9

实例化一个对象，传一个大模型
model = ChatTongyi（model='',temperature=3000)
实例化会话链，这里需要传入模型
conversation=ConversationChain（llm=model）
conversation.predict(input='123')
conversation.predict(input='456')
conversation.predict(input='一共有几个数字')
print(result)
conversation自动维护上下文信息

indexes

让langchain具备处理文档处理的能力，包括文档加载、检索、文档加载器、文本分割器、vectorstores、检索器。

文档加载器

1
2
3
4
5
6
7
8
9
10
11
12

引入loader工具
初始化对象
loader = UnstructureLoader('./data/衣服属性.txt,encoding='utf8')
加载数据到内存中（返回值是一个列表，每一个元素是一个document对象，对应原文件的一行数据
docs = loader.load
print(f'len-->{len(docs)}')
打印第一行数据
docs[0].page_content
langchian_community：证明是三方写的包（相比之下，三方打印更简洁了）
from langchian_community.document.loader import Textloader
textloader返回值是一个列表，每一个元素是一个document对象，对应原文件的所有数据

文档分割器：分割字符，按照字符长度

chunk_size= 多少数量切一块；chunk_over=重叠字符数；separator=按照分割符进行切割。既可以制定分隔符。

e.g.假设chunk size=500；chunk over=0；separator=句号；文本中有五个句子。第一个句子100个字符，第二个句子200个字符，第三个句子100；不超过500，则以上三个句子打包成一个chunk。但是第四个句子是200个字符。则放弃第四个句子。第四放到第二个chunk中

1
2
3
4
5
6
7

langchain.text.splitters import CharacterTextSplitter
创建分词器separator参数指的是分割的分隔符，chunk size指的是分割出来的每个块的大小，chunk overlap是指每个块之间重复的大小
CharacterTextSplitter(separator="",chunk_size=5,chunk_overlap=0)
一句话进行分割
text_splitter.split_text('a b c d e f')
多句话分割（传一个可迭代对象，列表）
text_splitter.create_documents('a b c d e f','e f g h')

缺点：

按数量进行切割，无法保存完整语义

如果读取的文档中某一段分隔符缺失，或者长段句子没有分隔符，则依旧存在句子过长的问题

只适合简单文本，不适应复杂文本

递归字符文本分割器

可以使用多个分隔符，依次使用分隔符，知道长度满足要求为止

separators=[‘\n\n’,’\n’,’ ‘]

语义文档分割器

基于语义相似性分割文本

计算成本较高，

适用于需要高度语义理解的场景（文档比较重要的情况，网页爬取就不需要了）

embedding文本之后，判断语义相似性。

字符-递归-语义（随复杂和重要程度递增）

其他专用分割器（MarkdownHeaderTextSplit）

按照你的章节去做切割，一章内大概都是一个意思

先实例化对象

markdown_spliter=MarkdownHeaderTextSplitter()

markdown_text=

docs = markdown_splitter.split_text(markdown_text)

再用对象去做切割

自定义分割器

chains回顾

连接LLM与其他组件，完成应用程序的开发过程

MESS

导演名称，年份、信息对称，返回的结果，使用dantic，从结果中提取出来。就是这个结果。看齐的类型。

字符分割器（characterTextSplitter）

字符分割器是基于，按照空格进行切分。按照指定的数量，递归字符文本分割器（recursive character textsplitter）

递归字符文本分割器是一种更智能的分割方法，它尝试在特定分割符处分割文本，以保持更好的语义完整性。

特点：

尝试在自然断点处分割文本

比简单的字符分割更能保持语义完整性

适用于结构化成都较高的文本，如markdown、html

运行流程：

首先尝试使用第一个分隔符（如“\n\n”)分割文本

如果分割后的快任然过大，则使用给下一个分割符继续分割

重复此过程，知道达到指定的chunk_size或则用完所有的分隔符

语义文档分割器：更高级的分割方法

基于语义相似性分割文本

能够更好地保持语义完整性

计算成本较高，处理大量文本时可能效率较低

使用于需要高度语义理解的场景

其他专用分割器

如markdownHeadTextSplitter

文本分割参数调优策略

chunk size

chunk overlap

separator参数

非文本

sql lite（在本地存一个文件）

similarity search查询相应的文档

检索器

vectordb.similarity_search()用途：直接调用向量数据库的相似度搜索功能。输入：查询字符串（query）和可选的返回数量（k）。输出：按相似度排序的文档列表。

其他应用领域包括：

1、语义搜索系统

2、推荐系统

3、文档聚类

4、异常检测

5、多模态系统

6、内容去重

7、知识图谱

8、情感分析：捕捉文本的（情感特征）

检索器的功能和vectordb.similarity_search()相似；

调用检索器的方法：具体实现方式不一样。

可以封装到langchain的chain里面。

检索器是langchain中负责信息检索的模块，通常与索引（indexes）模块（如向量存储、文档加载器）结合使用。它的核心功能是：

输入：接受用户查询（文本）

处理

输出：返回一组相关文档或文本片段

工作流程：

查询嵌入

相似性搜索

文档返回

后处理：对查询结果做一些加工，（返回k个文档，对k个文档进行排序、过滤或重新排名）

检索器的核心依赖：

嵌入模型：

向量储存：

相似性度量：

similarity：精确匹配；最相关的k个做一个返回

mmr：平衡相关性和多样性；返回k个；生成综合性报告

similarity score threshold 质量过滤； 动态数量； 不控制多样性；高精度筛选；

lambda_mult:控制多样性（仅MMR搜索有效）

vectordb as_retriever()

返回一个retriever对象，用于langchain链式调用

tf-idf retriever

MULTIQUERYRETRIEVER

Contexttual

使用语言模型查询，生成多个解锁器。

ensembel retriever

查询依旧，但是检索不唯一。两种，或者以上。向量检索，达到非常好的效果。

向量检索的好。

custom retriever 生成多个查询语句，不同方式进行检索。把三种方法结合起来，进行使用。在里面实现。集成base retriever。看看试验方式，retriever；企业里常见的是混合优化，结构化优化。

Agent

Agent是一种能够感知环境、进行决策和执行动作的智能实体。不同于传统的人工智能，Agent具备通过主动思考、调用工具去逐步完成给定目标的能力。

外部工具，保存语义理解和推理能力，任务规划能力

a=大模型+任务规划+执行（调用外部工具）+记忆

大脑、五官、四肢

点菜（任务是找吃的）；agent不知道，会调用美团、大众点评的api去搜附近美食，

自动给你点菜；最后在“付款”步骤，介入人工，避免支付风险。

用户提出任务：“agent启动；将输入和提示词模版结合，送给大模型

2、思考决策：大模型接受输入后，根据内置逻辑和提示词指导，进行思考

判断需要更多东西

是否需要工具

工具执行

结果反馈

循环

如果回答：当大模型判断任务已完成，无需额外工具即可回答时，它会生成最终的答案。

反思、自我批评、思考链、子任务分解

planning是计划，调用方法（搜索、调度、计算器的方法），完成规划里的任务

Action（一些需要调用，一些不需要调用外部工具）

先想（planing）再做；（循环）；再思考过程中，会产生上下文（放到memory里面）

任务规划（planning）；思考用户交代的任务

长短期记忆（memory）：聊天上下文，长期保留和回忆信息

langchain实现智能体

langchain提供了不同类型的代理（主要罗列了三种：）

zero-shot-react-description：代理使用react框架，仅基于工具的描述来确定

structured-chat-zero-shot-react-description结构化的参数输入

conversational-react-description：上下文保存到记忆里面。

agent_toolkits.load_tools import load_tools

from langchain.agent import initialize_agent

tools,llm,agenttype.zero_shot_react_description,verbose=True

提示词传入

agent.invoke()

initialize_agent(tools,model,agent_type.ZERO_SHOT_REACT_DESCRIPTION,VERBOSE=TRUE)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1、实例化大模型：
chatTongyi（model=‘qwen-max）
2、设置工具：
load_tools(wikipedia，llm-math，llm=model)
3、创建代理
initialize_agent(tools,model,agent_type.ZERO_SHOT_REACT_DESCRIPTION,VERBOSE=TRUE)
4、设置提示词并进行agent调用
prompt = 
result = agent.invoke(prompt)
print(f'result-->{result})
思考过程：思考-动作（循环）
finished chain
result-->

总结：

什么是langchain？本质是一个框架（目的是快速的智能应用的开发）

组件

models（嵌入模型（embedding model）、普通大模型、聊天大模型）

prompt（普通prompt、chatprompt）

chains（chain、LCEL)

output parsers（字符串解析器、列表解析器、json解析器、pydantic解析器）

memory（保存上下文信息，conversationchain..

indexes（文档加载器、文档分割器、向量存储）

检索器（基于问题，在知识库中检索出对应的答案）

Agent（智能体是什么？）

今日目标

• 掌握Ollama模块实现
• 熟练使用Streamlit
• 掌握基于Ollama平台Python语言聊天机器人实现

【熟悉】阿甘智聊机器人

项目介绍

随着人工智能技术的飞速发展，聊天机器人在多个领域得到了广泛应用，如客户服务、教育辅导、娱乐互动等。然而，现有的许多聊天机器人依赖于云端服务，这不仅可能导致用户数据隐私泄露，还可能因网络延迟影响用户体验。因此，开发一款本地部署的聊天机器人显得尤为重要。本地聊天机器人能够在用户本地环境中运行，确保数据的安全性和对话的实时性，同时也能根据用户的个性化需求进行定制和优化。

项目演示

项目技术架构

• 后端模型：利用 Ollama 平台的 Qwen 模型，该模型具备出色的自然语言处理能力，能够理解和生成自然语言文本，为聊天机器人提供核心的对话处理功能。

• 前端界面：采用 Streamlit 框架搭建用户界面，Streamlit 是一个简单易用的 Python 库，能够快速创建美观、交互式的 Web 应用，使用户能够通过网页与聊天机器人进行实时对话。

• 对话交互：用户可以通过 Streamlit 界面输入文本，聊天机器人基于 Qwen 模型对输入内容进行理解和处理，生成相应的回复并展示在界面上，实现流畅的对话交互。

• 模型调用：后端服务负责将用户输入传递给 Qwen 模型，并获取模型生成的回复，然后将回复内容返回给前端界面进行展示，确保对话的实时性和准确性。

• 界面展示：Streamlit 界面提供简洁明了的布局，包括输入框、发送按钮和对话展示区域，用户可以方便地输入问题并查看机器人的回答，提升用户体验。

项目开发环境

• 操作系统：支持主流操作系统，如 Windows、macOS 和 Linux。
• 依赖软件：需要安装 Python 环境以及 Ollama 平台和 Streamlit 库。
• 硬件要求：推荐配置较高的处理器和足够的内存，以确保模型的高效运行和良好的用户体验。

【熟练】Ollama模块实现

学习目标

能够使用Python调用本地部署大模型API，完成聊天对话功能

Qwen模型PythonAPI实现文本扩写

需求：通过python调用API实现基于qwen2在0.5b数据集下实现对文本的续写，用户输入一个简短的故事开头，系统能够生成一段连贯、有趣的续写内容。

细节: 本地需要先安装下依赖包.

pip install ollama

pip install langchain -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install langchain-community -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install dashscope -i https://pypi.tuna.tsinghua.edu.cn/simple

pip install streamlit==1.32.0

1
2
3
4

import ollama
response = ollama.chat(model='qwen2:0.5b',messages=[{'role': 'user', 'content': '从前有座山，山里有个庙，庙里有个和尚叫二等兵下士阿甘，续写一下', },])
print(response.message.content)
print(response['message']['content'])

Qwen模型PythonAPI实现文本问答

需求：构建一个简单的命令行交互程序，用户可以通过输入问题与AI模型进行对话。该程序将使用qwen2:0.5b语言模型。用户可以通过命令行输入问题，程序将调用AI模型生成回答，并将结果输出到终端。

1
2
3
4
5
6
7
8
9
10
11

import ollama
# 3. 定义一个循环
while True:
    # 4. 获取prompt提示词
    prompt = input("请输入您的问题：")
    response = ollama.chat(model='qwen2:0.5b',
                           messages=[{'role': 'user', 'content': prompt, }, ])
    # 5. 调用模型，回答问题
    result = response['message']['content']
    # 6. 打印回答
    print(result)

Qwen模型PythonAPI实现编程代码

需求：构建一个基于AI模型的代码生成工具，用户可以通过输入自然语言描述所需功能，AI模型将自动生成相应的Python代码。该工具旨在帮助开发者快速获取代码片段，减少手动编写代码的时间。

1
2
3
4
5
6
7
8
9
10
11
12

# 4. 获取prompt提示词
prompt = """
请为以下功能生成一段Python代码：
求两个数的最大公约数
"""
response = ollama.chat(model='qwen2:0.5b',
                       messages=[{'role': 'user', 'content': prompt}, ])
# 5. 调用模型，回答问题
result = response['message']['content']
# 6. 打印回答
print(result)

Qwen模型PythonAPI实现情感标签

需求：构建一个基于AI模型的用户反馈分类工具，用户可以通过输入具体的反馈内容，AI模型将自动将其归类到预设的类别中（如“价格过高”、“售后支持不足”、“产品使用体验不佳”、“其他”）。该工具旨在帮助企业快速分析用户反馈，识别主要问题，并采取相应的改进措施。

1
2
3
4
5
6
7
8
9
10
11
12
13

# 4. 获取prompt提示词
prompt = """
你需要对用户的反馈进行原因分类。
分类包括：价格过高、售后支持不足、产品使用体验不佳、其他。
回答格式为：分类结果：xx。
用户的问题是：性价比不高，我觉得不值这个价钱。
"""
response = ollama.chat(model='qwen2:0.5b',
                       messages=[{'role': 'user', 'content': prompt}, ])
# 5. 调用模型，回答问题
result = response['message']['content']
# 6. 打印回答
print(result)

小结

• 能够使用Python调用本地部署大模型API，完成聊天对话功能
  • 掌握基于Ollama平台调用Qwen模型
    • 文本扩写
    • 文本问答
    • 编程代码
    • 情感标签

【熟练】Streamlit

学习目标

实现基于Streamlit前端聊天页面开发

只用 Python 也能做出很漂亮的网站？Streamlit 说可以。

Streamlit 官方介绍：能在几分钟内把 Python 脚本变成可分享的网站。只需使用纯 Python ，无需前端经验。甚至，你只需要懂 markdown ，然后按照一定规则去做也能搞个网页出来。它还支持免费部署。

官方网站：https://streamlit.io/

Streamlit安装

首先你的电脑需要有 python 环境。

有 python 环境后，使用下面这条命令就可以安装 streamlit。

1

pip install streamlit==1.32.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

安装 streamlit 成功后可以使用下面这条命令看看能不能运行起来。

1

streamlit hello

基础语法

标题

使用 st.title() 可以设置标题内容。

1

st.title('Streamlit教程')

段落write

段落就是 HTML 里的 <p> 元素，在 streamlit 里使用 st.write('内容') 的方式去书写。

1
2
3

import streamlit as st

st.write('Hello')

使用markdown

streamlit 是支持使用 markdown 语法来写页面内容的，只需使用单引号或者双引号的方式将内容包起来，并且使用 markdown 的语法进行书写，页面就会出现对应样式的内容。

1
2
3
4
5
6
7
8

import streamlit as st

"# 1级标题"
"## 2级标题"
"### 3级标题"
"#### 4级标题"
"##### 5级标题"
"###### 6级标题"

图片

渲染图片可以使用 st.image() 方法，也可以使用 markdown 的语法。

st.image(图片地址, [图片宽度]) ，其中图片宽度不是必填项。

1
2
3

import streamlit as st

st.image('./avatar.jpg', width=400)

表格

streamlit 有静态表格和可交互表格。表格在数据分析里属于常用组件，所以 streamlit 的表格也支持 pandas 的 DataFrame 。

静态表格 table

静态表格使用 st.table() 渲染，出来的效果就是 HTML 的 <table>。

st.table() 支持传入字典、pandas.DataFrame 等数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import streamlit as st
import pandas as pd

st.write('dict字典形式的静态表格')
st.table(data={
    'name': ['张三', '李四', '王五'],
    'age': [18, 20, 22],
    'gender': ['男', '女', '男']
})

st.write('pandas中dataframe形式的静态表格')

df = pd.DataFrame(
    {
        'name': ['张三', '李四', '王五'],
        'age': [18, 20, 22],
        'gender': ['男', '女', '男']
    }
)
st.table(df)

可交互表格 dataframe

可交互表格使用 st.dataframe() 方法创建，和 st.table() 不同，st.dataframe() 创建出来的表格支持按列排序、搜索、导出等功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import streamlit as st
import pandas as pd

st.write('dict字典形式的可交互表格')
st.dataframe(data={
    'name': ['张三', '李四', '王五'],
    'age': [18, 20, 22],
    'gender': ['男', '女', '男']
})

st.write('pandas中dataframe形式的可交互表格')
df = pd.DataFrame(
    {
        'name': ['张三', '李四', '王五'],
        'age': [18, 20, 22],
        'gender': ['男', '女', '男']
    }
)
st.dataframe(df)

分割线

分隔线就是 HTML 里的 <hr> 。在 streamlit 里使用 st.divider() 方法绘制分隔线。

1
2
3

import streamlit as st

st.divider()

输入框

知道怎么声明变量后，可以使用一个变量接收输入框的内容。

输入框又可以设置不同的类型，比如普通的文本输入框、密码输入框。

• 普通输入框

输入框使用 st.text_input() 渲染。

1
2
3
4

name = st.text_input('请输入你的名字：')

if name:
  st.write(f'你好，{name}')

☆ 密码

如果要使用密码框，可以给 st.text_input() 加多个类型 type="password"。

1
2
3

import streamlit as st

pwd = st.text_input('密码是多少？', type='password')

☆ 数字输入框 number_input

数字输入框需要使用 number_input

1
2
3
4
5

import streamlit as st

age = st.number_input('年龄：')

st.write(f'你输入的年龄是{age}岁')

众所周知，正常表达年龄是不带小数位的，所以我们可以设置 st.number_input() 的步长为1，参数名叫 step。

1
2
3

# 省略部分代码

st.number_input('年龄：', step=1)

这个步长可以根据你的需求来设置，设置完后，输入框右侧的加减号每点击一次就根据你设置的步长相应的增加或者减少。

还有一点，人年龄不可能是负数，通常也不会大于200。可以通过 min_value 和 max_value 设置最小值和最大值。同时还可以通过 value 设置默认值。

1

st.number_input('年龄：', value=20, min_value=0, max_value=200, step=1)

多行文本框 text_area

创建多行文本框使用的是 st.text_area()，用法和 st.text_input() 差不多。

1
2
3

import streamlit as st

paragraph = st.text_area("多行内容：")

Chat Elements

• Chat文本输入框

  1 2 3 4 5

  import streamlit as st prompt = st.chat_input("Say something") if prompt: st.write(f"User has sent the following prompt: {prompt}")

• Chat Message

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 导入 Streamlit 库，Streamlit 是一个用于快速创建数据应用的 Python 库
import streamlit as st

# 使用 st.chat_input 创建一个聊天输入框，提示用户输入问题
prompt = st.chat_input('请输入您的问题: ')

st.write(f'您的问题是: {prompt}')

# 使用 st.chat_message 创建一个用户消息容器，用于显示用户的消息
# 'user' 表示这是用户发送的消息
with st.chat_message('user'):
    # 在用户消息容器中显示文本 'Hello '
    st.write('Hello ')

# 使用 st.chat_message 创建一个消息容器，用于显示回复消息
message = st.chat_message('assistant')
# 在消息容器中显示文本 'Hello Human'，模拟助手的回复
message.write('Hello Human')

小结

• 实现基于Streamlit前端页面开发
  • 标题：
  • 输入框
  • 多行文本框

【掌握】Ollama平台聊天机器人实现

学习目标

实现基于Python调用Qwen模型API接口聊天机器人开发

需求

构建一个基于大模型的本地智能聊天机器人，利用其强大的自然语言处理和生成能力，为用户提供高效、精准、个性化的对话服务。该聊天机器人将集成先进的大规模预训练语言模型（如GPT、Qwen等），具备自然语言理解、多轮对话、情感分析、知识问答等核心功能，并可根据具体应用场景进行定制化扩展，例如客服咨询、教育辅导、娱乐互动等。

项目采用模块化设计，前端通过Streamlit等框架实现简洁易用的交互界面，后端基于Ollama等平台进行模型部署和管理，确保系统的高效性和可扩展性。项目目标是打造一个智能化、人性化的聊天机器人，提升用户体验，降低人工成本，并探索大模型技术在不同领域的创新应用。

模型调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 1. 导入相关包
import ollama

# 2. 定义一个函数，用于发起请求，返回结果
# def get_response(prompt):
#     messages = []
#     messages.append({'role': 'user', 'content': prompt, })
#     response = ollama.chat(model='qwen2.5:7b', messages=messages)
#     return response['message']['content']

# 3. 定义一个函数，用于发起请求，返回结果
def get_response(prompt):
    # response = ollama.chat(model='qwen2:0.5b', messages=prompt[-50:])
    response = ollama.chat(model='deepseek-r1:8b', messages=prompt[-50:])
    return response['message']['content']


# 7. 测试，测试结束后，终止
if __name__ == '__main__':
    s=input("请输入你要表达的内容")
    while True:

        prompt = s
        result = get_response(prompt)
        print(result)

前端实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 1. 导入相关包，如streamlit包
import streamlit as st
from langchain.memory import ConversationBufferMemory
from utils import get_response

# 3. 主界面主标题
st.title("黑马智聊机器人")

# 5. 会话保持：用于存储会话记录
if "memory" not in st.session_state:
    st.session_state['memory'] = ConversationBufferMemory()
    st.session_state['messages'] = [{'role': 'assistant', 'content': '你好，我是黑马智聊机器人，有什么可以帮助你的么？'}]

# 6. 编写一个循环结构，用于打印会话记录
for message in st.session_state['messages']:
    with st.chat_message(message['role']):
        st.markdown(message['content'])

# 4. 创建一个聊天窗口
prompt = st.chat_input("请输入您要咨询的问题：")
# 7. 如果文本框有数据，继续向下执行
if prompt:
    st.session_state['messages'].append({'role': 'user', 'content': prompt})
    st.chat_message("user").markdown(prompt)
    # 10. 向utils工具箱发起请求，返回响应
    with st.spinner("AI小助手正在思考中..."):
        content = get_response(st.session_state['messages'])
    st.session_state['messages'].append({'role': 'assistant', 'content': content})
    st.chat_message("assistant").markdown(content)

小结

• 实现基于Python调用Qwen模型API接口聊天机器人开发
  • 实现前端页面开发
  • 完成后端Python业务代码实现

作业

结合自己写的聊天机器人,生成学生管理系统框架

LLM-Index

昨日回顾

1、output parsers

字符串解析器

列表解析器

json解析器

pydantic解析器

自定义解析器

2、memory

ChatMessageHistory

​ history.add_user_message(xxx)

​ history.add_ai_message(xxx)

​ message_to_dict()

​ messages_from_dict()

ConversationChain(自动管理上下文)

​ ConversationChain（llm=model）

​ conversation.predict(input=’xxx’)

3、Index(RAG核心组件)

文件加载器

​ 创建UnstructuredLoader对象load

​ docs = loader.load

​ html可以用自己的html对象

文档分割器

​ 创建文档分割器的对象（separator,chunk_size,chunk_overlap）

​ 单文档切割

​ 多文档切割(打印信息不同，打印出多个document的key，看不到具体内容)

vectorstores

​ 创建向量数据库Chroma（存入的文档，存入的路径，embedding）

​ 加载

​ 查询（要查询的问题，和匹配的文档k数）

检索器（和similarity search方法很相似 retriever=chromadaDB.as_retriever(search_kwargs={k:2})

​ result=retriever.invoke(query)

​ 可以设置检索时候的算法

agent

基于大模型对用户的问题进行思考，并调用工具完成任务：

​ 调用api（tools，model，AgentType.ZERO_SHOT_REACT_DESCRIPTION,verbose=True）

REACT(reason推理+act（调用工具完成任务）)循环往复。

tools=load_tools([wikipedia,’llm-math’],)

每一种类型（大概的理论，怎么调用，怎么改动）

项目为什么要调用哪些api

哪些组件、具体作用、使用方式（api）、知道如何修改

RAG项目实战

智能衣答系统（RAG)

物流行业信息咨询智能问答系统（RAG)

目标：用langchain搭建一个系统

解决问题：模型基于过去的经验数据完成训练，

基于企业自有知识微调

基于基于langchain

流程：

索引（数据预处理：文档读取进来，提取内容成字符串，切割成chunk，embedding chunk）

检索：（用户提问题，转换问题为向量embedding，用embedding做相似度（知识向量库里的）匹配 （用向量库做一个能匹配k个答案的检索器）

生成：匹配到top_K个,添加到prompt，提交给LLM生成答案

加载文件、读取文件、文本分割、文本向量化、问题向量、匹配出的k个，匹配出文本作为上下文和问题一起添加到prompt。

智能衣答系统（RAG)

1、项目需求

以一副属性构建本地知识

2、项目思路

离线部分

​ 文件加载

​ 文本切分

​ 向量化

​ 存向量库

在线部分

​ query向量化

​ 在文本向量中匹配出与问句向量相似的topk个

​ 匹配出的文本作为上下文和问题一起添加到prompt中

​ 提交给llm生成答案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

P02_project
	data
    project1
    	db.py
    	
from langchain_chroma import Chroma
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import CharacterTextSplitter
from P04_RAG.P02_project.project1.model import embedding

def create_db(file_path,chunk_size=150,chunk_overlap=30,persist_directory='./chroma_data')
	第一步：加载文档
	loader = TextLoader('../data/衣服属性.txt',encoding='utf-8')
	docs = loader.load()
	print(docs)
	第二步：切分文档
	text_splitter = CharacterTextSplitter(separator="\n",chunk_size=150,chunk_overlap=30)
	split_texts  = text_splitter.split_document(docs)
	第三步：将切好的文档存储到向量数据库中(只执行一次即可，下次运行就从模型中加载即可)

	Chroma.from_documents(documents=split_texts,
                     	embedding=embedding,
                     	persist_directory=persist_directory)


def get_retriever(embedding,k=2,persist_directory='./chroma_data'):
	从构建好的向量数据库中加载数据
	vectordb = Chroma（persist_directory='./chroma_data',embedding_function=embedding)
	第四步：生成一个检索器
	retriever = vectordb.as_retriever(search_kwargs={'k':k})
	return retriever
	
	
create_db(file_path,chunk_size=150,chunk_overlap=30,persist_directory='./chroma_data'
retriever=get_retriever(embedding,k=2,persist_directory='./chroma_data')

1
2
3
4
5
6
7
8
9
10
11
12
13

model.py

from langchain_community.chat_models import ChatTongyi
from langchain_community.embeddings import DashScopeEmbeddings
from dotenv import load_dotenv
### 加载环境变量
load_dotenv()

### 加载embedding模型
embedding = DashScopeEmbeddings()

### 加载对话的大模型
llm = ChatTongyi(model='qwen-plus')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

main.py



from langchain_core.prompts import PromptTemplate

from P04_RAG.P02_project.project1.db import get_retriever
from P04_RAG.P02_project.project1.model import embedding, llm

1、获取检索器
retriever = get_retriever(embedding)
def qa(question):
	2、将问题送入检索器，获取相似的top-k个文档
	
	docs = retriever.invoke(question)
	print(f'docs-->{docs})
	related_docs = [doc.page_content for doc in docs]
	print(f'related_docs-->{related_docs}')


	3、设置提示词模版，包括检索到的文档和用户的问题
	template_str = '''
	你是一个问答任务助手，使用以下检索到的上下文来回答问题，如果你不知道答案，只需说不知道，回答保持简洁。'''
	4、构造提示词
    prompt = template.format(question=question,context=related_docs)
	
	5、通过ChatMessageHistory()来存储上下文信息
	chat_history = ChatMessageHistory()
	chat_history.add_user_message(prompt)
	
	5、调用模型，生成答案
	result = llm.invoke(str(chat_history)).content
	print(f'result-->{result}')
	将大模型的输出保存到chat_history
	chat_history.add_ai_message(result)
	
	return result


if __name__ == __main__
question = '我身高170，体重140斤，买多大尺码'
retult = qa(question)

question = '我的体重是多少'
result = qa(question)

1
2
3
4
5
6
7
8
9
10
11
12
13

Conversational
condense question prompt:用于问题“重写”的提示模板
chain type链；stuff：全部塞进去给LLM(简单包里，’map reduce‘：先逐段问，再总结；)

把nexus584问大模型
prompt：nexus584的用户在7月末在csdn上发布了两篇文章，请把他的文章链接给我

chathistory
总结：使用ConversationalRetrieverchain
提示词模版+问题
原始的提示词；大模型的提示词（把对话信息加载进来了）

实现前端问答系统界面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import streamlit as st




st.title('智能衣答系统')
st.chat_input()
response = chat_history2[-1][1]

初始化会话状态，如果没有则创建

使用session state方式来储存对话历史，也就是将其设置为全局变量

user input



在页面上显示模型生成的回复

读取pdf，可以用不同的文档加载器的api ；called as PDF

Conda_Command

导出当前conda环境下所有的包的名字

1

conda env export > /你的指定路径/requir.txt

• 了解私有化大模型
• 掌握Ollama安装与部署
• 熟悉Ollama客户端命令
• 掌握基于Ollama平台的ChatBot聊天机器人

【了解】私有大模型

学习目标

了解私有化大模型解决方案，能够选择企业常用的方案实现私有大模型部署

为什么要有私有大模型

随着AI技术的不断普及，人们也积极拥抱其带来的变化，在生活或者工作中亦使用AI技术来帮助我们更高效的完成某些事件，但是在这个过程中，也暴露出AI技术当前下存在在的系列问题，其中最严重的就是安全问题

比如：最典型的是三星员工使用ChatGPT泄露公司机密的案例。

其实上述案例表现的就是企业数据隐私与安全的问题，在许多行业，如金融、医疗、政府等，数据隐私和安全是至关重要的。使用公共大模型可能涉及敏感数据的泄露风险，因为公共模型在训练过程中可能接触到了来自不同来源的敏感数据。因此就有了私有大模型的市场需求，私有大模型允许企业或机构在自己的数据上训练模型，而且训练的结果只供内部或合作伙伴使用，从而确保了数据隐私和安全。

当然除了数据隐私问题原因之外，还存有便于内部员工工作提效、大模型开发的投入等诸多原因综合，直接推动私有大模型成为未来AI发展的新方向之一。

私有大模型解决方案

随着AI的发展，越来越多的开发者投入到大模型开发中，他们期望能自身笔记本上运行大模型，以便开发。越来越多的企业积极改造自身产品，融入AI技术，他们期望能私有化大模型以保证数据安全。这些诉求直接推动社区出现了两个这方面的产品Ollama和LMstudio。

这两个产品各有优势：

选择私有化大模型部署方案

Ollama 作为一个开源的轻量级工具，适合熟悉命令行界面的开发人员和高级用户进行模型实验和微调。它提供了广泛的预训练模型和灵活的定制选项，同时保持了高度的便捷性和安全性。最重要它是开源的，同时还提供API，对于开发有先天优势，因此在企业中备受欢迎和使用，因此本课程也才主要学习Ollama技术。

小结

• 了解私有化大模型解决方案
  • Ollama：开源的大型语言模型本地运行框架
  • LM Studio：闭源的本地大型语言模型工作站，集模型训练、部署、调试于一体

【实操】Ollama安装与使用

学习目标

通过安装Ollama工具，实现基于Ollama运行通义QWen大模型

什么是Ollama

Ollama：是一款旨在简化大型语言模型本地部署和运行过程的开源软件。

中文名：羊驼

网址：https://ollama.com/

Ollama提供了一个轻量级、易于扩展的框架，让开发者能够在本地机器上轻松构建和管理LLMs（大型语言模型）。通过Ollama，开发者可以访问和运行一系列预构建的模型，或者导入和定制自己的模型，无需关注复杂的底层实现细节。

Ollama的主要功能包括快速部署和运行各种大语言模型，如Llama 2、Code Llama等。它还支持从GGUF、PyTorch或Safetensors格式导入自定义模型，并提供了丰富的API和CLI命令行工具，方便开发者进行高级定制和应用开发。

Ollama特点

• 一站式管理：
  • Ollama将模型权重、配置和数据捆绑到一个包中，定义成Modelfile，从而优化了设置和配置细节。
  • 包括GPU使用情况。这种封装方式使得用户无需关注底层实现细节，即可快速部署和运行复杂的大语言模型。
• 热加载模型文件：
  • 支持热加载模型文件，无需重新启动即可切换不同的模型，
  • 提高了灵活性，还显著增强了用户体验。
• 丰富的模型库：提供多种预构建的模型，如Llama 2、Llama 3、通义千问，方便用户快速在本地运行大型语言模型。
• 多平台支持：支持多种操作系统，包括Mac、Windows和Linux，确保了广泛的可用性和灵活性。
• 无复杂依赖：优化推理代码减少不必要的依赖，可以在各种硬件上高效运行。包括纯CPU推理和Apple Silicon架构。
• 资源占用少：Ollama的代码简洁明了，运行时占用资源少，使其能够在本地高效运行，不需要大量的计算资源。

Ollama下载与安装

Ollama下载

Ollama共支持三种平台：

• Window：https://ollama.com/download/OllamaSetup.exe
• Mac：https://ollama.com/download/Ollama-darwin.zip
• Linux：https://ollama.com/download/ollama-linux-amd64

Windows平台安装

• Windows安装

  1 2 3 4 5

  第一步：在02_资料/OllamaSetup.exe 找到执行程序 第二步：右键以管理员身份运行 第三步：点击install

  

• 验证安装成功

  1 2 3 4 5 6 7

  第一步：win+R组合键 输入cmd 第二步： 输入命令 ollama -v 第三步：显示ollama版本号 ollama version is 0.5.4 即安装成功！

  

Linux下载与安装

• 手动安装

  window和mac版本直接下载安装或解压即可使用。这里由于Ollama需要安装在linux中，因此在这里主要学习如何在Linux上安装：

  Step 1. 安装

  在虚拟机/root/resource目录中已经下载好Linux版本所需的ollama-linux-amd64.tgz文件，则执行下面命令开始安装：

  1	>tar -C /usr -xzf ollama-linux-amd64.tgz

  操作成功之后，可以通过查看版本指令来验证是否安装成功

  1 2 3

  >[root@bogon resource]# ollama -v >Warning: could not connect to a running Ollama instance >Warning: client version is 0.3.9

  Step 2. 添加开启自启服务

  创建服务文件/etc/systemd/system/ollama.service，并写入文件内容：

  1 2 3 4 5 6 7 8 9 10 11 12 13

  >[Unit] >Description=Ollama Service >After=network-online.target >[Service] >ExecStart=/usr/bin/ollama serve >User=root >Group=root >Restart=always >RestartSec=3 >[Install] >WantedBy=default.target

  生效服务：

  1 2	systemctl daemon-reload >systemctl enable ollama

  启动服务：

  1	>sudo systemctl start ollama

• 一键安装

  Ollama在Linux上也提供了简便的安装命令，但是过程中需要下载400M左右的数据，比较慢，因此课堂上采用第一种方式安装，但在工作中一般采用下面命令进行安装：

  1	curl -fsSL https://ollama.com/install.sh | sh

运行通义千问大模型

首次运行

通义千问（Qwen）是阿里巴巴集团Qwen团队研发的大语言模型和大型多模态模型系列。Qwen具备自然语言理解、文本生成、视觉理解、音频理解、工具使用、角色扮演、作为AI Agent进行互动等多种能力。

官网：https://qwen.readthedocs.io/zh-cn

在终端输入一下命令即可运行通义千问大模型： ollama run qwen2:0.5b

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

[root@bogon resource]# ollama run qwen2:0.5b
pulling manifest 
pulling 8de95da68dc4... 100% ▕█████████████████████████████████████████████████████████████████████████████████▏ 352 MB                         
pulling 62fbfd9ed093... 100% ▕█████████████████████████████████████████████████████████████████████████████████▏  182 B                         
pulling c156170b718e... 100% ▕█████████████████████████████████████████████████████████████████████████████████▏  11 KB                         
pulling f02dd72bb242... 100% ▕█████████████████████████████████████████████████████████████████████████████████▏   59 B                         
pulling 2184ab82477b... 100% ▕█████████████████████████████████████████████████████████████████████████████████▏  488 B                         
verifying sha256 digest 
writing manifest 
removing any unused layers 
success 
>>> 您好
你好！有什么可以帮助你的？

>>> 你是什么大模型
我是来自于阿里云的预训练模型，我叫通义千问。我可以回答您关于计算机科学、机器学习等领域的各种问题，也可以进行自然语言处理、聊天机器人、智能问答等任务。我的设计目的是让计算机能够像人类一样思考和解决问题。

命令解释：

第1行：为运行一个本地大模型的命令，这个命令的格式为：

1

ollama run 模型名称:模型规模

第2~11行：如果首次运行，本地没有大模型则会从远程下载大模型

第12~16行：运行成功模型之后，通过终端进行对话聊天

修改模型路径

直接运行上述小节命令，会下载300多M的数据，比较慢，而在虚拟机中已经提前下载好了相关模型（包括后续用到的模型），存储在/root/ollama目录中，因此这里我们需要修改ollama的模型路径，ollama软件在各个操作系统上的默认存储路径是：

macOS: ~/.ollama/models
Linux: ~/.ollama/models
Windows: ~/.ollama/models

要修改其默认存储路径，需要通过设置系统环境变量来实现，即在/etc/profile文件中最后增加一下环境变量：

1

export OLLAMA_MODELS=/root/ollama

然后执行一下命令，生效环境变量：

1
2
3
4

[root@bogon ollama]# source /etc/profile
[root@bogon ollama]# echo $OLLAMA_MODELS
/root/ollama
[root@bogon ollama]# 

然后重新ollama服务，则会跳过下载，直接进入大模型，对话完成后可以通过/bye指令终止对话：

1
2
3
4
5
6
7
8

[root@bogon ollama]# systemctl stop ollama
[root@bogon ollama]# ollama serve &
[root@bogon ~]#  ollama run qwen2:0.5b
>>> 您好
很高兴为您服务！有什么问题或需要帮助的吗？

>>> /bye
[root@bogon ~]# 

让重启也支持模型路径：

上述方式修改后，通过ollama命令是生效的，但是重启电脑则不生效，要解决这个问题，则还需要进行如下配置：

修改服务文件/etc/systemd/system/ollama.service内容为一下：：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/bin/ollama serve
User=root
Group=root
Restart=always
RestartSec=3
Environment="OLLAMA_MODELS=/root/ollama"

[Install]
WantedBy=default.target

生效修改的配置：

1
2

systemctl daemon-reload
systemctl restart ollama

对话指令初体验

在Ollama终端中提供了一系列指令，可以用来调整和控制对话模型：

/? 该指令主要是列出支持的指令列表

1
2
3
4
5
6
7
8
9
10
11
12
13

[root@bogon ~]#  ollama run qwen2:0.5b
>>> /?
Available Commands:
  /set            Set session variables
  /show           Show model information
  /load <model>   Load a session or model
  /save <model>   Save your current session
  /clear          Clear session context
  /bye            Exit
  /?, /help       Help for a command
  /? shortcuts    Help for keyboard shortcuts

Use """ to begin a multi-line message.

小结

• 通过安装Ollama工具，实现基于Ollama运行通义QWen大模型
  • 完成Ollama软件安装
  • 实现Qwen模型本地部署

【熟悉】对话指令详解

学习目标

掌握基于Ollama客户端相关命令，完成对大模型进行操作

/bye 指令

退出当前控制台对话, 快捷键: ctrl + d

1
2
3
4
5
6

[root@bogon ~]#  ollama run qwen2:0.5b
>>> 您好
你好！有什么可以帮助您的吗？

>>> /bye
[root@bogon ~]# 

/show指令

/show 指令：用于查看当前模型详细信息

1 2 3 4 5 6 7 8 9

[root@bogon ~]# ollama run qwen2:0.5b >>> /show Available Commands: /show info 查看模型的基本信息 /show license 查看模型的许可信息 /show modelfile 查看模型的制作源文件Modelfile /show parameters 查看模型的内置参数信息 /show system 查看模型的内置Sytem信息 /show template 查看模型的提示词模版

/show info 查看模型的基本信息

1 2 3 4 5

>>> /show info Model details: Family qwen2 模型名称 Parameter Size 494.03M 模型大小 Quantization Level Q4_0 模型量化级别

/show license 查看模型的许可信息—开源软件的许可协议

1 2 3 4 5 6 7 8

>>> /show license Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION ............................................................

/show modelfile 查看模型的制作源文件Modelfile

modelfile ：文件是用来制作私有模型的脚步文件，后续课程学习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

>>> /show modelfile
# Modelfile generated by "ollama show"
# To build a new Modelfile based on this, replace FROM with:
# FROM qwen2:0.5b

FROM /root/ollama/blobs/sha256-8de95da68dc485c0889c205384c24642f83ca18d089559c977ffc6a3972a71a8
TEMPLATE "{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
{{ .Response }}<|im_end|>
"
PARAMETER stop <|im_start|>
PARAMETER stop <|im_end|>
LICENSE """
......................................................................

/show parameters 查看模型的内置参数信息

1
2
3
4

>>> /show parameters
Model defined parameters:
stop                           "<|im_start|>"
stop                           "<|im_end|>"

/show system 查看模型的内置system信息—system常常用来定一些对话角色扮演

1
2

>>> /show system
No system message was specified for this model.

/show template 查看模型的提示词模版

template：是最终传入大模型的字符串模版，模版中的内容由上层应用动态传入

1
2
3
4
5
6
7

>>> /show template
{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
{{ .Response }}<|im_end|>

/? shortcuts 指令

查看在控制台中可用的快捷键

1
2
3
4
5
6
7
8
9
10
11
12
13

>>> /? shortcuts
Available keyboard shortcuts:
  Ctrl + a            移动到行头
  Ctrl + e            移动到行尾
  Ctrl + b            移动到单词左边
  Ctrl + f            移动到单词右边
  Ctrl + k            删除游标后面的内容
  Ctrl + u            删除游标前面的内容
  Ctrl + w            删除游标前面的单词

  Ctrl + l            清屏
  Ctrl + c            停止推理输出
  Ctrl + d            退出对话（只有在没有输入时才生效）

“”” 指令

“”” 用于输入内容有换行时使用，如何多行输入结束也使用 “””

1
2
3
4
5

>>> """
... 您好
... 你是什么模型？
... """ 
我是一个计算机程序，可以回答您的问题、提供信息和执行任务。请问您有什么问题或者指令想要我帮助您？

/set 指令

set指令主要用来设置当前对话模型的系列参数

1
2
3
4
5
6
7
8
9
10
11
12
13

>>> /set
Available Commands:
  /set parameter ...     设置对话参数
  /set system <string>   设置系统角色
  /set template <string> 设置推理模版
  /set history           开启对话历史
  /set nohistory         关闭对话历史
  /set wordwrap          开启自动换行
  /set nowordwrap        关闭自动换行
  /set format json       输出JSON格式
  /set noformat          关闭格式输出
  /set verbose           开启对话统计日志
  /set quiet             关闭对话统计日志

/set parameter … 设置对话参数

1
2
3
4
5
6
7
8
9
10
11
12

>>> /set parameter
Available Parameters:
  /set parameter seed <int>             Random number seed
  /set parameter num_predict <int>      Max number of tokens to predict
  /set parameter top_k <int>            Pick from top k num of tokens
  /set parameter top_p <float>          Pick token based on sum of probabilities
  /set parameter num_ctx <int>          Set the context size
  /set parameter temperature <float>    Set creativity level
  /set parameter repeat_penalty <float> How strongly to penalize repetitions
  /set parameter repeat_last_n <int>    Set how far back to look for repetitions
  /set parameter num_gpu <int>          The number of layers to send to the GPU
  /set parameter stop <string> <string> ...   Set the stop parameters

JSON格式输出

1
2
3
4
5
6
7
8
9

>>> /set format json
Set format to 'json' mode.
>>> 您好
{"response":"你好，欢迎光临，请问有什么我可以帮助您的吗？"}

>>> /set noformat
Disabled format.
>>> 您好
Hello! How can I assist you?

输出对话统计日志

1
2
3
4
5
6
7
8
9
10
11
12
13

>>> /set verbose
Set 'verbose' mode.
>>> 您好
您好！我需要您的信息，以便回答您的问题。请问您能告诉我更多关于这个主题的信息吗？

total duration:       1.642906162s			总耗时
load duration:        3.401367ms			加载模型数据耗时
prompt eval count:    11 token(s)			提示词token消耗数量
prompt eval duration: 196.52ms				提示词处理耗时
prompt eval rate:     55.97 tokens/s		提示词处理速率
eval count:           24 token(s)			响应token消耗数量
eval duration:        1.304188s				响应处理耗时
eval rate:            18.40 tokens/s		响应处理速率

/clear 指令

在命令行终端中对话是自带上下文记忆功能，如果要清除上下文功能，则使用/clear指令清除上下文内容，例如：

前2个问题都关联的，在输入/clear则把前2个问题的内容给清理掉了，第3次提问时则找不到开始的上下文了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

>>> 请帮我出1道java list的单选题 
以下是一些关于Java List的单选题：

1. 在Java中，List是哪一种数据结构？
2. Java中的顺序存储方式（例如：使用数组）主要用来做什么？
3. 一个列表对象可以包含哪些类型的元素？

>>> 再出1道
以下是一些关于Java List的单选题：

4. 在Java中，List接口用于创建和操作集合。
5. Java中的顺序存储方式（如：使用数组）的主要优势有哪些？
6. 一个列表对象可以包含哪些类型？

>>> /clear
Cleared session context
>>> 在出1道
很抱歉，我无法理解您的问题。您能否提供更多的背景信息或者问题描述，以便我能更好地帮助您？

/load 指令

load可以在对话过程中随时切换大模型

1
2
3
4
5
6
7
8
9

>>> 你是什么大模型
我是一个基于开放AI平台的模型，拥有一个强大的数学推理能力，并且在各种自然语言处理任务上都表现优秀。我可以回答您提出的问题，也可以提供与主题相关的信息和建议。如果您有任何问题或需要帮助，
请随时告诉我！

>>> /load deepseek-coder
Loading model 'deepseek-coder'
>>> 你是什么大模型
我是由中国的深度求索（DeepSeek）公司开发的编程智能助手，名为 Deepseek Coder。我主要用于解答和协助计算机科学相关的问题、问题解决方案等任务。我的设计目标是提供最全面准确的高质量服务来帮
助用户理解复杂的新技术或概念并迅速找到它们在实际应用中的实现方法或者原理所在的地方。

/save 指令

可以把当前对话模型存储成一个新的模型

1
2

>>> /save test
Created new model 'test'

保存的模型存储在ollama的model文件中，进入下面路径即可看见模型文件test：

1
2
3
4

[root@bogon library]# pwd
/root/ollama/manifests/registry.ollama.ai/library
[root@bogon library]# ls
deepseek-coder  qwen2  test

小结

• 掌握基于Ollama客户端相关命令
  • /bye指令 ：退出当前控制台对话
  • /show指令：用于查看当前模型详细信息
  • /load指令：可以在对话过程中随时切换大模型
  • /set指令：指令主要用来设置当前对话模型的系列参数
  • clear指令：清除上下文内容

【熟练】客户端命令详解

Ollama客户端还提供了系列命令，来管理本地大模型，接下来就先了解一下相关命令：

run 命令

run命令主要用于运行一个大模型，命令格式是：

1
2
3

ollama run MODEL[:Version] [PROMPT] [flags]
比如，运行通义千问命令：
ollama run qwen2:0.5b

[:Version] 可以理解成版本，而版本信息常常以大模型规模来命名，可以不写，不写则模式成latest

1
2
3

ollama run qwen2
等同
ollama run qwen2:latest

[PROMPT] 参数是用户输入的提示词，如果带有此参数则，run命令会执行了输入提示词之后即退出终端，即只对话一次。

1
2
3
4

[root@bogon ~]#  ollama run qwen2:0.5b 您好
您好！有什么问题我可以帮助您？

[root@bogon ~]# 

[flags] 指定运行时的参数

1
2
3
4
5
6

Flags:
      --format string      指定运行的模型输出格式 (比如. json)
      --insecure           使用非安全模，比如在下载模型时会忽略https的安全证书
      --keepalive string   指定模型在内存中的存活时间
      --nowordwrap         关闭单词自动换行功能
      --verbose            开启统计日志信息

例如，在启动时增加 –verbose参数，则在对话时，自动增加统计token信息：

1
2
3
4
5
6
7
8
9
10
11
12
13

[root@bogon ~]# ollama run qwen2:0.5b --verbose
>>> 您好
欢迎光临，我可以为您提供帮助。有什么问题或需要帮助的地方？

total duration:       1.229917477s
load duration:        3.027073ms
prompt eval count:    10 token(s)
prompt eval duration: 167.181ms
prompt eval rate:     59.82 tokens/s
eval count:           16 token(s)
eval duration:        928.995ms
eval rate:            17.22 tokens/s

show 命令

不用运行大模型，查看模型的信息，与之前所学的/show功能类似。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[root@bogon ~]# ollama show -h
Show information for a model

Usage:
  ollama show MODEL [flags]

Flags:
  -h, --help         查看使用帮助
      --license      查看模型的许可信息
      --modelfile    查看模型的制作源文件Modelfile
      --parameters   查看模型的内置参数信息
      --system       查看模型的内置Sytem信息
      --template     查看模型的提示词模版

例如，查看提示词模版：

1
2
3
4
5
6
7

[root@bogon ~]# ollama show qwen2 --template
{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
{{ .Response }}<|im_end|>

pull 命令

查询模型名称的网站：https://ollama.com/

从远程下载一个模型，命令格式是：

1

ollama pull MODEL[:Version] [flags]

[:Version] 可以理解成版本，但在这里理解成大模型规模，可以不写，不写则模式成latest

1
2
3

ollama pull qwen2
等同
ollama pull qwen2:latest

[flags] 参数，目前只有一个–insecure参数，用于来指定非安全模式下载数据

1

ollama pull qwen2 --insecure

list/ls 命令

查看本地下载的大模型列表，也可以使用简写ls

1
2
3
4
5
6
7
8
9
10

[root@bogon ~]# ollama list
NAME                    ID              SIZE    MODIFIED       
qwen2:latest            e0d4e1163c58    4.4 GB  10 minutes ago  
deepseek-coder:latest   3ddd2d3fc8d2    776 MB  3 hours ago     
qwen2:0.5b              6f48b936a09f    352 MB  8 hours ago     
[root@bogon ~]# ollama ls
NAME                    ID              SIZE    MODIFIED       
qwen2:latest            e0d4e1163c58    4.4 GB  10 minutes ago  
deepseek-coder:latest   3ddd2d3fc8d2    776 MB  3 hours ago     
qwen2:0.5b              6f48b936a09f    352 MB  8 hours ago   

列表字段说明：

• NAME：名称
• ID：大模型唯一ID
• SIZE：大模型大小
• MODIFIED：本地存活时间

注意：在ollama的其它命令中，不能像docker一下使用ID或ID缩写，这里只能使用大模型全名称。

ps 命令

查看当前运行的大模型列表，PS命令没其它参数

1
2
3

[root@bogon ~]# ollama ps
NAME                    ID              SIZE    PROCESSOR       UNTIL                   
deepseek-coder:latest   3ddd2d3fc8d2    1.3 GB  100% CPU        About a minute from now 

列表字段说明：

• NAME：大模型名称
• ID：唯一ID
• SIZE：模型大小
• PROCESSOR：资源占用
• UNTIL：运行存活时长

rm 命令

删除本地大模型，RM命令没其它参数

1
2
3
4
5
6
7
8
9
10
11
12

[root@localhost system]# ollama ls
NAME                    ID              SIZE    MODIFIED     
qwen2:latest            e0d4e1163c58    4.4 GB  16 hours ago    
deepseek-coder:latest   3ddd2d3fc8d2    776 MB  19 hours ago    
qwen2:0.5b              6f48b936a09f    352 MB  24 hours ago    
[root@localhost system]# ollama rm qwen2:0.5b
deleted 'qwen2:0.5b'
[root@localhost system]# ollama ls
NAME                    ID              SIZE    MODIFIED     
qwen2:latest            e0d4e1163c58    4.4 GB  16 hours ago    
deepseek-coder:latest   3ddd2d3fc8d2    776 MB  19 hours ago    
[root@localhost system]# 

【掌握】OllamaAPI 详解

学习目标

掌握基于Ollama API接口，实现基于API的方式访问

HTTP基础知识

什么是HTTP

HTTP，全称为超文本传输协议（HyperText Transfer Protocol），是互联网上应用最为广泛的一种网络协议。它是客户端和服务器之间进行通信的规则集合，允许将超文本标记语言（HTML）文档从Web服务器传输到Web浏览器。简而言之，HTTP是Web浏览器和Web服务器之间的“语言”，使得用户能够浏览网页、下载文件、提交表单等。

HTTP请求特征

HTTP请求是客户端（如浏览器）向服务器发送的请求消息，用于获取或操作资源。以下是HTTP请求的主要特征：

请求方法
请求方法定义了客户端希望执行的操作类型，常见方法包括：

• GET：请求获取指定资源。
• POST：向服务器提交数据，通常用于表单提交。

请求URL
请求URL指定了资源的路径，通常包括协议（如HTTP或HTTPS）、服务器地址、端口号和资源路径。

请求头（Headers）
请求头包含关于请求的附加信息，常见字段包括：

• Host：指定服务器的主机名和端口号。
• User-Agent：描述客户端的信息（如浏览器类型）。
• Accept：指定客户端能够接收的媒体类型。
• Content-Type：指示请求体的媒体类型（如application/json）。
• Authorization：包含认证信息（如Bearer Token）

请求体（Request Body）

请求体用于携带客户端发送的数据，通常在POST、PUT等方法中使用。例如：

• 表单数据：username=test&password=123456
• JSON数据：{"username": "test", "password": "123456"}

HTTP请求体方法对比

​ 在HTTP协议中，GET和POST是两种最常用的请求方法，它们在用途、数据传递方式、安全性等方面有显著区别。

• GET：
  • 用于请求资源，通常用于从服务器获取数据（如加载网页、查询数据）。
  • 适合幂等操作（多次请求不会对资源产生影响）。
• POST：
  • 用于提交数据，通常用于向服务器发送数据（如表单提交、文件上传）。
  • 适合非幂等操作（多次请求可能会对资源产生影响）。

HTTP状态码分类

​ 200 OK：请求成功，响应中包含请求的数据。

​ 302 Found：资源临时移动到新URL。

​ 404 Not Found：请求的资源不存在。

​ 500 Internal Server Error：服务器内部错误，无法完成请求。

​ 502 Bad Gateway：服务器作为网关时收到无效响应。

API 详解

Ollama对客户端相关的命令也提供API操作的接口，方便在企业应用中通过程序类操作私有大模型。

开通远程访问

为了在本机（开发环境）中能访问虚拟机中的Ollama API，我们需要先开通Ollama的远程访问权限：

Step 1：增加环境变量

在/etc/profile中增加一下环境变量：

1
2

export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_ORIGINS=*

然后通过一下命令，生效环境变量：

1

source /etc/profile

Step 2：增加服务变量

修改服务文件/etc/systemd/system/ollama.service内容为一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/bin/ollama serve
User=root
Group=root
Restart=always
RestartSec=3
Environment="OLLAMA_MODELS=/root/ollama"
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_ORIGINS=*"

[Install]
WantedBy=default.target

生效修改的配置：

1
2

systemctl daemon-reload
systemctl restart ollama

Step 3：开通防火墙

1
2

firewall-cmd --zone=public --add-port=11434/tcp --permanent
firewall-cmd --reload

也可以关闭防火墙：

1

systemctl stop firewalld

导入Apifox文档

为了方便后续使用程序接入Ollama中的大模型，在此可以先通过Apifox进行Api的快速体验与学习。在资料文件夹中《Ollama.apifox.json》文件提供了供Apifox软件导入的json内容，再此我们先导入到Apifox软件中，快速体验一下API相关功能。

Step 1：打开导入项目

Step 2：选择导入的文件

Step 3：输入项目名称

Step 4：完成导入，进入项目

中间如果有导入预览，则直接点击确定即可。

配置环境地址

Oallma支持的API可以在资料文件夹中通过《Ollama API文档.html》了解详解，双击打开查看：

通过网页可以了解到Ollama支持7个API （这里只列举了常用的），接下来我们重点先了解对话和向量化接口，因为这两个接口是最重要的，其它接口则留给大家课后自行尝试，但是在正式体验之前，需要先配置一下环境地址。

配置测试环境地址：

聊天对话接口说明

聊天对话接口，是实现类似ChatGPT、文心、通义千问等网页对话功能的关键接口，请求的地址与参数如下：

POST /api/chat

{
“model”: “qwen2:0.5b”,
“messages”: [
​ {
​ “role”: “user”,
​ “content”: “你好”
​ }
],

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

{
  "model": "qwen2.5:0.5b",
  "messages": [
    {
      "role": "string",
      "content": "string",
      "images": "string"
    }
  ],
  "format": "string",
  "stream": true,
  "keep_alive": "string",
   "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_current_weather",
        "description": "Get the current weather for a location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The location to get the weather for, e.g. San Francisco, CA"
            },
            "format": {
              "type": "string",
              "description": "The format to return the weather in, e.g. 'celsius' or 'fahrenheit'",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["location", "format"]
        }
      }
    }
  ],
  "options": {
    "seed": 0,
    "top_k": 0,
    "top_p": 0,
    "repeat_last_n": 0,
    "temperature": 0,
    "repeat_penalty": 0,
    "stop": [
      "string"
    ]
  }
}

• 请求参数

返回示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

{
    "model": "llama3.1",
    "created_at": "2024-09-07T09:00:57.035084368Z",
    "message": {
        "role": "assistant",
        "content": "",
        "tool_calls": [
            {
                "function": {
                    "name": "get_current_weather",
                    "arguments": {
                        "format": "celsius",
                        "location": "Paris"
                    }
                }
            }
        ]
    },
    "done_reason": "stop",
    "done": true,
    "total_duration": 14452649821,
    "load_duration": 21370256,
    "prompt_eval_count": 213,
    "prompt_eval_duration": 11306354000,
    "eval_count": 25,
    "eval_duration": 3082983000
}

• 返回结果

• 返回数据结构

状态码 200 时才返回以下信息。

• 对话操作演示

视觉对话演示

随着技术与算力的进步，大模型也逐渐分化成多种类型，而在这些种类中比较常见的有：

• 大语言模型：用于文生文，典型的使用场景是：对话聊天—仅文字对话

  Qwen、ChatGLM3、Baichuan、Mistral、LLaMA3、YI、InternLM2、DeepSeek、Gemma、Grok 等等

• 文本嵌入模型：用于内容的向量化，典型的使用场景是：模型微调

  text2vec、openai-text embedding、m3e、bge、nomic-embed-text、snowflake-arctic-embed

• 重排模型：用于向量化数据的优化增强，典型的使用场景是：模型微调

  bce-reranker-base_v1、bge-reranker-large、bge-reranker-v2-gemma、bge-reranker-v2-m3

• 多模态模型：用于上传文本或图片等信息，然后生成文本或图片，典型的使用场景是：对话聊天—拍照批改作业

  Qwen-VL 、Qwen-Audio、YI-VL、DeepSeek-VL、Llava、MiniCPM-V、InternVL

• 语音识别语音播报：用于文生音频、音频转文字等，典型的使用场景是：语音合成

  Whisper 、VoiceCraft、StyleTTS 2 、Parler-TTS、XTTS、Genny

• 扩散模型：用于文生图、文生视频，典型的使用场景是：文生图

  AnimateDiff、StabilityAI系列扩散模型

在这些模型中，Ollama目前仅支持大语言模型、文本嵌入模型、多模态模型，文本嵌入模型在后面的会学习，再此可以先来体验一下多模态模型：

Step 1：私有化多模态大模型

LLaVA（ Large Language and Vision Assistant）是一个开源的多模态大模型，它可以同时处理文本、图像和其他类型的数据，实现跨模态的理解和生成。

网址:https://github.com/haotian-liu/LLaVA.git

1

ollama run llava --keepalive 1h

Step 2：准备图片素材

准备一张图片：

然后通过程序把图片数据转出Base64字符串：

1
2
3
4
5
6
7
8
9
10
11

import base64
def main():
    # 读取文件内容
    with open("..Snipaste_2024-06-22_16-01-31.png", "rb") as file:
        bytes_data = file.read()
    # 将字节数据编码为Base64字符串
    base64_str = base64.b64encode(bytes_data).decode('utf-8')
    # 打印Base64字符串
    print(base64_str)
if __name__ == "__main__":
    main()

生成的Base64也可以在【资料/多模态测试图片Base64字符串.txt 】中找到。

Step 3：调用多模态接口

在Ollama中可以通过内容生成接口和聊天对话接口来支持多模态，在此以聊天对话接口为例：

• 图片信息通过images字段传入，且可传入多张
• 识别的结果为引文，需要自行翻译

小结

• 掌握基于Ollama API接口
  • 了解大模型网络调用流程

【实操】ChatBox与Ollama快速搭建ChatBot

学习目标

掌握ChatBox环境搭建，完成ChatBox集成Ollama实现对话

ChatBox是什么

在当前市场上有很多类似ChatGPT、通义、文心、星火等这样的对话大模型供我们使用，帮助我们快速高效的完成日常的工作，但是对于一些企业来说，会存在一些数据安全的问题，因为您输入到大模型中的内容，会进过内部训练，成为大模型的一部分数据。就比如《三星被曝因ChatGPT泄露芯片机密！韩媒：数据「原封不动」传美国》，三星员工把一些内部资料输入到了ChatGPT，则ChatGPT拿到这些资料后，经过训练成模型数据，这样全球用户就都可以访问到这个数据。

企业为避免类似的情况发生，可以采取部署企业私有大模型的方案来解决此问题，这就引出了接下要学习的知识：搭建企业私有ChatBot。要完成这个知识需要先学习一个ChatBox的软件，我们接下来看一下：

Chatbox 是一款基于人工智能技术的对话工具，通常用于提供智能客服、聊天机器人或其他自动化对话服务。它可以帮助企业或个人实现高效的客户沟通、问题解答、任务处理等功能。

ChatBox功能特点包含：

• 一键免费拥有你自己的 ChatGPT/Gemini/Claude/Ollama 应用
• 与文档和图片聊天
• 代码神器：生成与预览
• 支持本地大模型
• 支持多平台AI接入
• 支持插件扩展

安装ChatBox

ChatBox提供了windows桌面安装方式，相关文件已下载到02_资料/Chatbox-1.9.8-Setup.exe，可以找到文件，然后通过以下操作进行安装：

**Step 1：桌面win安装 **

Step 2：访问ChatBox

ChatBox界面介绍

主界面

主界面如下，主要包括的内容有：

• 功能菜单（左侧）
  • 对话菜单
  • 功能菜单
• 模型选择

对话聊天界面

从主界面中点击【立即开始】则可快速进入聊天界面，然后与大模型进行聊天

• 聊天区域：用户可以发送文本、图片等信息，与大模型进行对话
• 聊天历史：显示历史用户与大模型对话列表
• 聊天设置：可以进行对话模型切换与参数设置

ChatBox集成Ollama

ChatBox对话聊天实际是调用的第三方AI平台，并且支持非常丰富的平台：

• AWS Bedrock：集成了 AWS Bedrock 服务，支持了 Claude / LLama2 等模型，提供了强大的自然语言处理能力。
• Google AI (Gemini Pro、Gemini Vision)：接入了 Google 的 Gemini 系列模型，包括 Gemini 和 Gemini Pro，以支持更高级的语言理解和生成。
• Anthropic (Claude)：接入了 Anthropic 的 Claude 系列模型，包括 Claude 3 和 Claude 2，多模态突破，超长上下文，树立行业新基准。
• ChatGLM：加入了智谱的 ChatGLM 系列模型（GLM-4/GLM-4-vision/GLM-3-turbo），为用户提供了另一种高效的会话模型选择。
• Moonshot AI (月之暗面)：集成了 Moonshot 系列模型，这是一家来自中国的创新性 AI 创业公司，旨在提供更深层次的会话理解。
• Together.ai：集成部署了数百种开源模型和向量模型，无需本地部署即可随时访问这些模型。
• 01.AI (零一万物)：集成了零一万物模型，系列 API 具备较快的推理速度，这不仅缩短了处理时间，同时也保持了出色的模型效果。
• Groq：接入了 Groq 的 AI 模型，高效处理消息序列，生成回应，胜任多轮对话及单次交互任务。
• OpenRouter：其支持包括 Claude 3，Gemma，Mistral，Llama2和Cohere等模型路由，支持智能路由优化，提升使用效率，开放且灵活。
• Minimax: 接入了 Minimax 的 AI 模型，包括 MoE 模型 abab6，提供了更多的选择空间。
• DeepSeek: 接入了 DeepSeek 的 AI 模型，包括最新的 DeepSeek-V2，提供兼顾性能与价格的模型。
• Qwen: 接入了 Qwen 的 AI 模型，包括最新的 qwen-turbo，qwen-plus 和 qwen-max 等模型。

除此之外，ChatBox也支持与本地私有部署的大模型就行对话，而这种组合使用场景非常适合数据敏感的企业。

要在ChatBox中使用Ollama中的大模型，也非常便捷，可以按照以下步骤进行操作：

Step 1：运行本地大模型

1

ollama run qwen2 --keepalive 1h

命令说明：

• 命令运行的是通义大模型
• 通过--keepalive参数设置大模型被加载到内存中的存活时长为1小时

Step 2：配置Ollama信息

进入对话聊天界面，并点击位置的设置按钮，则弹出下图中间区域的对话框，然后点击位置的【模型】菜单，然后按图填写信息：

Step 3：开始对话

配置完成之后，返回对话界面，在1号位置选择通义大模型，然后即可开始对话聊天。

小结

• 掌握ChatBox环境搭建
  • 完成ChatBox软件安装
  • 实现ChatBox部署Qwen大模型

【扩展】Windows版本的Ollama安装与DeepSeek大模型部署

cmd进入黑窗口平台

1

键盘组合键 win+r 输入cmd

下载deepseek模型

1

ollama pull deepseek-r1:1.5b

体验deepseek模型

1

ollama run deepseek-r1:1.5b

1 RNN介绍

1.1 RNN概念

循环神经网络（Recurrent Neural Network, RNN）是一种==专门处理序列数据的神经网络==。与传统的前馈神经网络不同，RNN具有“循环”结构，能够处理和记住前面时间步的信息，使其特别适用于时间序列数据或有时序依赖的任务。

我们要明确什么是序列数据，时间序列数据是指在不同时间点上收集到的数据，这类数据反映了某一事物、现象等随时间的变化状态或程度。这是时间序列数据的定义，当然这里也可以不是时间，比如文字序列，但总归序列数据有一个特点——后面的数据跟前面的数据有关系。

1.2 RNN应用场景

• 自然语言处理（NLP）：文本生成、语言建模、机器翻译、情感分析等。
• 时间序列预测：股市预测、气象预测、传感器数据分析等。
• 语音识别：将语音信号转换为文字。
• 音乐生成：通过学习音乐的时序模式来生成新乐曲。

1.3 自然语言处理概述

自然语言处理（Nature language Processing, NLP）研究的主要是==通过计算机算法来理解自然语言。==

对于自然语言来说，处理的数据主要就是人类的语言，例如：汉语、英语、法语等，该类型的数据不像我们前面接触过的结构化数据、或者图像数据可以很方便的进行数值化。

NLP的目标是让机器能够“听懂”和“读懂”自然语言，并进行有效的交流和分析。

NLP涵盖了从文本到语音、从语音到文本的各个方面，它涉及多种技术，包括语法分析、语义理解、情感分析、机器翻译等。

2 词嵌入层

在 RNN（Recurrent Neural Network） 中，词嵌入层（Word Embedding Layer） 是处理自然语言数据的关键组成部分。它将输入的离散单词（通常是词汇表中的索引）转换为连续的、低维的向量表示，从而使得神经网络能够理解和处理这些词汇的语义信息。

2.1 词嵌入层作用

词嵌入层的主要目的是将每个词映射为一个固定长度的向量（将文本转换为向量），这些向量能够捕捉词与词之间的语义关系。

传统的文本表示方法（如one-hot编码）无法反映单词之间的相似性，因为在one-hot编码中，每个单词都被表示为一个高维稀疏向量，而词嵌入通过低维稠密向量表示单词，能够更好地捕捉词汇之间的语义相似性。

词嵌入层首先会根据输入的词的数量构建一个词向量矩阵，例如: 我们有 100 个词，每个词希望转换成 128 维度的向量，那么构建的矩阵形状即为: 100*128，输入的每个词都对应了一个该矩阵中的一个向量。

词嵌入层在RNN中的作用：

• 输入表示：RNN通常用于处理序列数据。在处理文本时，RNN的输入是由单词构成的序列。由于神经网络不能直接处理离散的单词标识符（如整数索引或字符），因此需要通过词嵌入层将每个单词转换为一个固定长度的稠密向量。这些向量作为RNN的输入，帮助RNN理解词语的语义。
• 降低维度：词嵌入层将原本高维的稀疏表示（如one-hot编码）转化为低维的稠密向量，减少了计算量，同时保持了词汇之间的语义关系。
• 捕捉语义相似性：通过训练，词嵌入能够学习到词语之间的关系。例如，语义相似的词（如“猫”和“狗”）在向量空间中会比较接近，而语义不相关的词（如“猫”和“汽车”）则会较为遥远。

2.2 词嵌入层工作流程

• 初始化词向量：词嵌入层的初始词向量通常会使用随机初始化或者通过加载预训练的词向量（如Word2Vec或GloVe）进行初始化。

• 输入索引：每个单词在词汇表中都有一个唯一的索引。输入文本（例如一个句子）会先被分词，然后每个单词会被转换为相应的索引。

• 查找词向量：词嵌入层将这些单词索引映射为对应的词向量。这些词向量是一个低维稠密向量，表示该词的语义。

• 输入到RNN：这些词向量作为RNN的输入，RNN处理它们并根据上下文生成一个序列的输出。

2.3 词嵌入层使用

在PyTorch中，我们可以使用 nn.Embedding 词嵌入层来实现输入词的向量化。

nn.Embedding 对象构建时，最主要有两个参数:

• num_embeddings：表示词的数量

• embedding_dim：表示用多少维的向量来表示每个词

1

nn.Embedding(num_embeddings=10, embedding_dim=4)

接下来，我们将会学习如何将词转换为词向量，其步骤如下:

1. 先将语料进行分词，构建词与索引的映射，我们可以把这个映射叫做词表，词表中每个词都对应了一个唯一的索引；
2. 然后使用 nn.Embedding 构建词嵌入矩阵，词索引对应的向量即为该词对应的数值化后的向量表示。

例如，我们的文本数据为: “北京冬奥的进度条已经过半，不少外国运动员在完成自己的比赛后踏上归途。”，接下来，我们看下如何使用词嵌入层将其进行转换为向量表示，步骤如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import torch
import torch.nn as nn
import jieba # pip install jieba -i https://pypi.mirrors.ustc.edu.cn/simple/


if __name__ == '__main__':
    # 0.文本数据
    text = '北京冬奥的进度条已经过半，不少外国运动员在完成自己的比赛后踏上归途。'
    # 1. 文本分词
    words = jieba.lcut(text)
    print('文本分词:', words)
    # 2.分词去重并保留原来的顺序获取所有的词语
    unique_words = list(set(words))
    print("去重后词的个数:\n",len(unique_words))
    # 3. 构建词嵌入层
    # num_embeddings: 表示词的总数量
    # embedding_dim: 表示词嵌入的维度
    embed = nn.Embedding(num_embeddings=len(unique_words), embedding_dim=4)
    print("词嵌入的结果：\n",embed)
    # 4. 词语的词向量表示
    for i, word in enumerate(unique_words):
        # 获得词嵌入向量
        word_vec = embed(torch.tensor(i))
        print('%s\t' % word, word_vec)

输出结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

文本分词: ['北京', '冬奥', '的', '进度条', '已经', '过半', '，', '不少', '外国', '运动员', '在', '完成', '自己', '的', '比赛', '后', '踏上', '归途', '。']
去重后词的个数:
 18
词嵌入的结果：
 Embedding(18, 4)
 北京	 tensor([-1.8043,  1.7860, -0.7821, -0.3167], grad_fn=<EmbeddingBackward0>)
  的	 tensor([-1.4856, -0.5639,  0.2745,  0.1087], grad_fn=<EmbeddingBackward0>)
 冬奥	 tensor([ 0.6969, -0.5615,  1.6524, -0.2651], grad_fn=<EmbeddingBackward0>)
 自己	 tensor([1.7163, 0.9710, 0.0193, 1.4562], grad_fn=<EmbeddingBackward0>)
 不少	 tensor([ 0.8770, -1.0347,  0.4939,  1.6718], grad_fn=<EmbeddingBackward0>)
 归途	 tensor([ 0.0619,  0.0355, -1.6510,  0.8121], grad_fn=<EmbeddingBackward0>)
 比赛	 tensor([-1.7128,  0.0681,  2.4199,  0.2714], grad_fn=<EmbeddingBackward0>)
进度条	 tensor([-0.6706,  0.4089, -0.5371,  0.1093], grad_fn=<EmbeddingBackward0>)
 外国	 tensor([ 0.5665, -0.3168, -0.2065,  0.7682], grad_fn=<EmbeddingBackward0>)
 完成	 tensor([ 1.4640, -0.2800, -0.2242, -0.3790], grad_fn=<EmbeddingBackward0>)
 过半	 tensor([ 1.8026,  0.9831, -0.7177,  0.6779], grad_fn=<EmbeddingBackward0>)
 踏上	 tensor([-1.0745, -0.2610, -1.5350, -0.1767], grad_fn=<EmbeddingBackward0>)
运动员	 tensor([1.8748, 0.2093, 1.9471, 0.3893], grad_fn=<EmbeddingBackward0>)
  ，	 tensor([-1.2841, -0.0675, -0.1263, -0.6892], grad_fn=<EmbeddingBackward0>)
  在	 tensor([ 0.6202, -0.0106,  1.0504,  0.0299], grad_fn=<EmbeddingBackward0>)
 已经	 tensor([2.4461, 0.2113, 0.9387, 0.1680], grad_fn=<EmbeddingBackward0>)
  后	 tensor([-1.1989,  0.8727, -0.9484,  0.0578], grad_fn=<EmbeddingBackward0>)
  。	 tensor([0.4020, 0.7357, 0.3571, 1.2355], grad_fn=<EmbeddingBackward0>)

3 循环网络层

文本数据是具有序列特性的，例如: “我爱你”, 这串文本就是具有序列关系的，”爱” 需要在 “我” 之后，”你” 需要在 “爱” 之后, 如果颠倒了顺序，那么可能就会表达不同的意思。

为了表示出数据的序列关系，我们需要使用循环神经网络(Recurrent Nearal Networks, RNN) 来对数据进行建模，RNN 是一个具有记忆功能的网络，它作用于处理带有序列特点的样本数据。

3.1 RNN网络层原理

当我们希望使用循环网络来对 “我爱你” 进行语义提取时，RNN计算过程是什么样的呢？

上图中h表示==隐藏状态==，隐藏状态保存了序列数据中的历史信息，并将这些信息传递给下一个时间步，从而允许RNN处理和预测序列数据中的元素。

每一次的输入都会包含两个值：上一个时间步的隐藏状态、当前状态的输入值x

每一次的输出都会包含两个值：输出当前时间步的隐藏状态、当前时间步的预测结果y

隐藏状态作用：

• 记忆功能：隐藏状态就像RNN的记忆，它能够在不同的时间步之间传递信息。当一个新的输入进入网络时，当前的隐藏状态会结合这个新输入来生成新的隐藏状态。

• 上下文理解：由于隐藏状态携带了过去的信息，它可以用于理解和生成与上下文相关的输出。这对于语言模型、机器翻译等任务尤其重要。

• 连接不同时间步：隐藏状态通过网络内部的循环连接将各个时间步连接起来，使得网络可以处理变长的序列数据。

上图中，为了更加容易理解，虽然画了 3 个神经元, 但是实际上只有一个神经元，”我爱你” 三个字是重复输入到同一个神经元中。

我们举个例子来理解上图的工作过程，假设我们要实现文本生成，也就是输入 “我爱” 这两个字，来预测出 “你”，其如下图所示:

将上图展开成不同时间步的形式，如下图所示:

首先初始化出第一个隐藏状态，一般都是全0的一个向量，然后将 “我” 进行词嵌入，转换为向量的表示形式，送入到第一个时间步，然后输出隐藏状态 h1，然后将 h1 和 “爱” 输入到第二个时间步，得到隐藏状态 h2, 将 h2 送入到全连接网络，得到 “你” 的预测概率。

RNN神经元内部是如何计算的呢？

**1. 计算隐藏状态：**每个时间步的隐藏状态$$h_t$$是根据当前输入$$x_t$$和前一时刻的隐藏状态$$h_{t-1}$$计算的。

上述公式中:

• $$W_{ih}$$ 表示输入数据的权重
• $$b_{ih}​$$ 表示输入数据的偏置
• $$W_{hh}​$$ 表示输入隐藏状态的权重
• $$b_{hh}$$ 表示输入隐藏状态的偏置
• $$h_{t-1}$$ 表示输入隐藏状态
• $$h_t​$$ 表示输出隐藏状态

最后对输出的结果使用tanh激活函数进行计算，得到该神经元你的输出隐藏状态。

**2. 计算当前时刻的输出：**网络的输出$$y_t$$是当前时刻的隐藏状态经过一个线性变换得到的。

​ $$y_t=W_{hy}h_t+b_y​$$

• $$y_t​$$ 是当前时刻的输出（通常是一个向量，表示当前时刻的预测值，RNN层的预测值）
• $$h_t​$$ 是当前时刻的隐藏状态
• $$W_{hy}$$ 是从隐藏状态到输出的权重矩阵
• $$b_y$$ 是输出层的偏置项

3. 词汇表映射：输出$$y_t$$是一个向量，该向量经过全连接层后输出得到最终预测结果$$y_{pred}$$，$$y_{pred}$$中每个元素代表当前时刻生成词汇表中某个词的得分（或概率，通过激活函数：如softmax）。==词汇表有多少个词，$$y_{pred}$$就有多少个元素值，最大元素值对应的词就是当前时刻预测生成的词。==

神经元工作机制总结：

• 接收输入：每个RNN神经元接收来自输入数据$$x_t$$和前一时刻的隐藏状态$$h_{t-1}$$。

• 更新隐藏状态：神经元通过一个加权和（由权重矩阵和偏置项组成）更新当前时刻的隐藏状态$$h_t​$$，该隐藏状态包含了来自过去的记忆以及当前输入的信息。

• 输出计算：基于当前隐藏状态$$h_t​$$，神经元生成当前时刻的输出$$y_t​$$，该输出可以用于任务的最终预测。

  

文本生成示例：

假设我们使用RNN进行文本生成，输入是一个初始词语或一段上下文（例如，“m”）。RNN会通过隐藏状态逐步生成下一个词的概率分布，然后根据概率选择最可能的下一个词。

1. 输入：“m” → 词向量输入$$x_1$$（对应“m”）

2. 初始化隐藏状态$$h_0​$$，一般初始值为0

3. 隐藏状态更新$$h_1​$$，并计算输出$$y_1​$$

4. 经过全连接层输出层计算输出$$y_{pred}​$$，使用softmax函数将$$y_{pred}​$$转换为概率分布

5. 选择概率最高的词作为输出词（例如“a”）

6. 输入新的词“a”，继续处理下一个时间步，直到生成完整的词或句子

**小结：**在循环神经网络中，词与输出的对应关系通常通过以下几个步骤建立

1. 词嵌入：将词转化为向量表示（词向量）。
2. RNN处理：通过RNN层逐步处理词向量，生成每个时间步的隐藏状态。
3. 输出映射：通过线性变换将隐藏状态映射到输出，通常是一个词汇表中的词的概率分布。

3.2 PyTorch RNN层的使用

• API介绍

  1	RNN = nn.RNN(input_size, hidden_size，num_layers)

  参数意义是：

  • input_size：输入数据的维度，一般设为词向量的维度
  • hidden_size：隐藏层h的维度，也是当前层神经元的输出维度
  • num_layers: 隐藏层h的层数，默认为1

• 输入数据和输出结果

  将RNN实例化就可以将数据送入其中进行处理，处理的方式如下所示：

  1	output, hn = RNN(x, h0)

  • 输入数据：主要包括词嵌入的x 、初始的隐藏层h0
    • x的表示形式为[seq_len, batch, input_size]，即[句子的长度，batch的大小，词向量的维度]
    • h0的表示形式为[num_layers, batch, hidden_size]，即[隐藏层的层数，batch的大小，隐藏层h的维度]
  • 输出结果：主要包括输出结果output,最后一层的hn
    • output的表示形式与输入x类似，为[seq_len, batch, input_size]，即[句子的长度，batch的大小，输出向量的维度]
    • hn的表示形式与输入h0一样，为[num_layers, batch, hidden_size]，即[隐藏层的层数，batch的大，隐藏层h的维度]

• API使用

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  import torch import torch.nn as nn # RNN层送入批量数据 def test(): # 词向量维度 128, 隐藏向量维度 256 rnn = nn.RNN(input_size=128, hidden_size=256) # 第一个数字: 表示句子长度,也就是词语个数 # 第二个数字: 批量个数，也就是句子的个数 # 第三个数字: 词向量维度 inputs = torch.randn(5, 32, 128) hn = torch.zeros(1, 32, 256) # 获取输出结果 output, hn = rnn(inputs, hn) print("输出向量的维度：\n",output.shape) print("隐藏层输出的维度：\n",hn.shape) if __name__ == '__main__': test()

  输出结果：

  1 2 3 4

  输出向量的维度： torch.Size([5, 32, 256]) 隐藏层输出的维度： torch.Size([1, 32, 256])

4 文本生成案例

文本生成任务是一种常见的自然语言处理任务，输入一个开始词能够预测出后面的词序列。本案例将会使用循环神经网络来实现周杰伦歌词生成任务。

4.1 导入工具包

1
2
3
4
5
6

import torch
import jieba
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.optim as optim
import time

4.2 数据集

我们收集了周杰伦从第一张专辑《Jay》到第十张专辑《跨时代》中的歌词，来训练神经网络模型，当模型训练好后，我们就可以用这个模型来创作歌词。数据集如下：

1
2
3
4
5
6
7
8
9
10
11

想要有直升机
想要和你飞到宇宙去
想要和你融化在一起
融化在宇宙里
我每天每天每天在想想想想著你
这样的甜蜜
让我开始相信命运
感谢地心引力
让我碰到你
漂亮的让我面红的可爱女人
...

该数据集共有 5819 行文本。

4.3 构建词表

在进行自然语言处理任务之前，首要做的就是构建词表。

所谓的词表就是将语料进行分词，然后给每一个词分配一个唯一的编号，便于我们送入词嵌入层。

接下来, 我们对周杰伦歌词的数据进行处理构建词表，具体流程如下：

• 获取文本数据
• 分词，并进行去重
• 构建词表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# 获取数据，并进行分词，构建词表
def build_vocab():
    # 数据集位置
    file_name = 'data/jaychou_lyrics.txt'
    # 分词结果存储位置
    # 唯一词列表
    unique_words = []
    # 每行文本分词列表
    all_words = []
    # 遍历数据集中的每一行文本
    for line in open(file_name, 'r', encoding='utf-8'):
        # 使用jieba分词,分割结果是一个列表
        words = jieba.lcut(line)
        # print(words)
        # 所有的分词结果存储到all_words，其中包含重复的词组
        all_words.append(words)
        # 遍历分词结果，去重后存储到unique_words
        for word in words:
            if word not in unique_words:
                unique_words.append(word)
    # 语料中词的数量
    word_count = len(unique_words)
    # 词到索引映射
    word_to_index = {word: idx for idx, word in enumerate(unique_words)}
    # 歌词文本用词表索引表示
    corpus_idx = []
    # 遍历每一行的分词结果
    for words in all_words:
        temp = []
        # 获取每一行的词，并获取相应的索引
        for word in words:
            temp.append(word_to_index[word])
        # 在每行词之间添加空格隔开
        temp.append(word_to_index[' '])
        # 获取当前文档中每个词对应的索引
        corpus_idx.extend(temp)
    return unique_words, word_to_index, word_count, corpus_idx


if __name__ == "__main__":
    # 获取数据
    unique_words, word_to_index, unique_word_count, corpus_idx = build_vocab()
    print("词的数量：\n",unique_word_count)
    print("去重后的词:\n",unique_words)
    print("每个词的索引：\n",word_to_index)
    print("当前文档中每个词对应的索引：\n",corpus_idx)

我们的词典主要包含了:

• unique_words: 存储了每个词

• word_to_index: 存储了词到编号的映射

  

4.4 构建数据集对象

我们在训练的时候，为了便于读取语料，并送入网络，所以我们会构建一个Dataset对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class LyricsDataset(torch.utils.data.Dataset):
	def __init__(self, corpus_idx, num_chars):
		# 文档数据中词的索引
		self.corpus_idx = corpus_idx
		# 每个句子中词的个数
		self.num_chars = num_chars
		# 文档数据中词的数量，不去重
		self.word_count = len(self.corpus_idx)
		# 句子数量
		self.number = self.word_count // self.num_chars

	# len(obj)时自动调用此方法
	def __len__(self):
		# 返回句子数量
		return self.number

	# obj[idx]时自动调用此方法
	def __getitem__(self, idx):
		# idx指词的索引，并将其修正索引值到文档的范围里面
		"""
		我 爱你 中国 , 亲爱 的 母亲
		word_count: 7
		num_chars: 2 一个句子由num_chars个词组成
		word_count-num_chars-2: 7-2-1=4  -1:网络预测结果y在x上后移一个词取值-1
		idx=5->start=4
		"""
		start = min(max(idx, 0), self.word_count - self.num_chars - 1)
		end = start + self.num_chars
		# 输入值
		x = self.corpus_idx[start: end]
		# 网络预测结果（目标值）
		y = self.corpus_idx[start + 1: end + 1]
		# 返回结果
		return torch.tensor(x), torch.tensor(y)


if __name__ == "__main__":
	# 获取数据
	unique_words, word_to_index, unique_word_count, corpus_idx = build_vocab()
	# 数据获取实例化
	dataset = LyricsDataset(corpus_idx, 5)
	# 查看句子数量
	print('句子数量：', len(dataset))
	# x, y = dataset.__getitem__(0)
	x, y = dataset[0]
	print("网络输入值：", x)
	print("目标值：", y)

输出结果：

1
2
3

句子数量： 9827
网络输入值： tensor([ 0,  1,  2,  3, 40])
目标值： tensor([ 1,  2,  3, 40,  0])

4.5 构建网络模型

我们用于实现《歌词生成》的网络模型，主要包含了三个层:

• 词嵌入层: 用于将语料转换为词向量

• 循环网络层: 提取句子语义

• 全连接层: 输出对词典中每个词的预测概率

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# 模型构建
class TextGenerator(nn.Module):
    def __init__(self, unique_word_count):
        super(TextGenerator, self).__init__()
        # 初始化词嵌入层: 语料中词的数量, 词向量的维度为128
        self.ebd = nn.Embedding(unique_word_count, 128)
        # 循环网络层: 词向量维度128, 隐藏向量维度256, 网络层数1
        self.rnn = nn.RNN(128, 256, 1)
        # 输出层: 特征向量维度256与隐藏向量维度相同, 词表中词的个数
        self.out = nn.Linear(256, unique_word_count)
        
    def forward(self, inputs, hidden):
        # 输出维度: (batch, seq_len, 词向量维度128)
        # batch：句子数量
        # seq_len： 句子长度， 每个句子由多少个词 词数量
        embed = self.ebd(inputs)
        # rnn层x的表示形式为(seq_len, batch, 词向量维度128)
        # output的表示形式与输入x类似，为(seq_len, batch, 词向量维度256)
        # 前后的hidden形状要一样, 所以DataLoader加载器的batch数要能被整数
        output, hidden = self.rnn(embed.transpose(0, 1), hidden)
        # 全连接层输入二维数据， 词数量*词维度
        # 输入维度: (seq_len*batch, 词向量维度256) 
        # 输出维度: (seq_len*batch, 语料中词的数量)
        # output: 每个词的分值分布，后续结合softmax输出概率分布
        output = self.out(output.reshape(shape=(-1, output.shape[-1])))
        # 网络输出结果
        return output, hidden
    
    def init_hidden(self, bs):
        # 隐藏层的初始化:[网络层数, batch, 隐藏层向量维度]
        return torch.zeros(1, bs, 256)
    
    
if __name__ == "__main__":
	# 获取数据
	unique_words, word_to_index, unique_word_count, corpus_idx = build_vocab()
	model = TextGenerator(unique_word_count)
	for named, parameter in model.named_parameters():
		print(named)
		print(parameter)