零基础创建一个可以对话的人工智能,保姆级教学，提供了完整可运行的代码，感兴趣但不会python按照步骤来也可以学会

调用API（Application Programming Interface，应用程序编程接口）是指软件程序之间进行交互的一种方式。API定义了组件之间的接口，包括操作、输入和输出格式等，以便不同的软件系统能够相互沟通和交换数据。

当你调用API时，你实际上是在请求另一个服务或程序执行特定的功能或返回某些信息。这个过程通常涉及到以下步骤：

发送请求：客户端（可以是网站、移动应用或其他软件）向提供API的服务端发送一个请求。这个请求通常包含了必要的参数，比如想要获取的数据类型、用户认证信息等。

处理请求：服务端接收到请求后，会根据API的规则来解析请求，并执行相应的业务逻辑或查询数据库等操作。

返回响应：一旦服务端完成了请求的操作，它会将结果打包成一种预定义的格式（如JSON、XML等），并通过网络发送回给客户端。

使用响应：客户端接收到来自API的响应后，可以解析这些数据并以适当的方式展示给用户，或者用于进一步的处理。

二：自行训练模型型（更进一步开发AI）

解释：

调用API时使用的是申请API的那个AI，但是自己训练模型不是这样，无需调用API，通俗来说，就是训练出的模型，完全是可以按照自己内心想法，给AI提供训练数据，让AI进行针对性训练的，这一点的好处是，可以让AI训练成我们想要的样子，例如提高AI对话的权重，或者提高AI对算法逻辑或者编程逻辑的权重。但是要完成自行训练模型，需要的设备要求可能会比较高。

下文开始教学，可根据需要，通过目录前往不同类型的AI教学处

基础设备的安装与创建新项目：

一：安装编程设备

无论是第一类型还是第二类型的对话型AI，都需要安装一些基础设备：编程软件( pycharm )

如果是有python基础的人，可以跳过这一步，vscode等等也是可以完成此项目的，如果是小白零基础建议按照教学安装：

1. 如果电脑有应用商店，可以在应用商店下载pycharm community（ pycharm社区版），不要下载错了，pycharm professional（ pycharm专业版）是要花钱的，社区版是免费的。

如果电脑应用商店没有找到社区版，可以前往网址jetbrains.com下载，进去后往下翻，找到pycharm，如图：

点进去后会有download按钮，点进去：

进去之后会有2个版本，专业版在上面，页面往下翻找到社区版，下载到 windows即可，无需下载到windows arm64:

二：安装编程所需应用，创建新项目

打开pycharm后选择新建项目会出现如下界面：

因为我这个是专业版，所以部分功能在社区版没有，只看我标记位置即可。

①：选择自定义环境

②：选择如图所示环境，用于创建虚拟环境（最好创建一个）

③：如果电脑里没有python，可以点击右边向下小箭头，点击下载最新版本。

备注：项目名称可以自己取名，如果python下载无效，请继续往下看，如果下载成功，请进入下一标题学习

如果python下载无效教程：

进入网址python.org 页面下翻，找到如图所示，点击进去：

进去后继续页面下翻，下载如图所示python最新版:

下载好python后一定要记住位置，然后进入pycharm新建项目页面，选择python版本（一般来说pycharm会自动检测到python），然后就可以进入下一步教学了！

到这里需要用到的设备就安装完成了，下面开始创建对话AI教学，可根据需求跟着目录前

第一类型AI教学（调用API型）：

第一步：安装所需的库

如果要与API进行交互，我们需要安装一些python的库，主要的库是requests，我们可以通过这个库发送我们的HTTP请求。

在pycharm中，打开“Terminal”（终端）窗口。如图：

然后在终端输入命令然后按下回车键来安装requests库，如图所示:

pip install requests

若出现序号②，并且并且上面显示（除notice外）一样，说明安装成功。

若出现序号①，说明python版本不是最新，把绿色命令复制粘贴运行即可

第二步：获取API（这里以豆包大模型的API为例）

我们通过账号登录-火山引擎链接访问火山引擎的页面

登录之后在主页面上面的搜索框搜索:“火山方舟”即可进入控制台

我们在控制台，点击API key管理，如图：

进入之后点击创建 API Key，其中的名称是可以自定义的，如图：

创建好后，这里是你的API Key：

注意：API密钥是非常敏感的信息，请妥善保管，非到万不得已，一定不要泄露给他人！

第三步：创建主程序文件

现在，我们可以开始编写代码了。

首先，创建一个主程序文件，右键你的项目文件，选择“新建”，选择“python文件即可，文件名称可以自行命名，比如main.py（注意：可以不用写”.py“，因为创建的时候，pycharm会自动补充".py"），命名完成后回车即可，如图

最后创建完成应该是这样的：

第五步：编写代码与API交互

接下来请不要跳着看，一步一步跟着教程写代码

在main.py文件（你自己创建的文件，不一定是main.py）中，我们编写代码，用于发送请求到豆包的API，并处理响应。

首先，我们需要导入requests库，如图所示：

import requests

接下来，我们需要定义API和URL和所需的headers，如图所示：

请注意，你需要将Authorization头中的令牌替换为你自己的有效令牌，

例如：如果我的API KEY是fhqiqxfiqowgfaxnqgfowqcmak

那么Authorization头中应该写：

"Bearer fhqiqxfiqowgfaxnqgfowqcmak"。

url = "https://ark.cn-beijing.volces.com/api/v3/chat/completions"

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer ea764f0f-3b60-45b3-****-************"
}

接下来，定义请求的数据，如图所示。

注意，确保将model字段替换为豆包API所要求的模型名称，模型名称在哪找如图所示：

data = {
    "model": "ep-20240704******-*****",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "Hello!"
        }
    ]
}

模型名称找法，点击如图所示方框进入在线推理：

然后点击创建接入点：

名称之类的可以自定义，接下来点击新建模型：

然后根据介绍选择一个自己喜欢的模型就好啦：

紧接着点击右边确认就好啦，使用前请看清楚计费标准，模型有一些免费赠送的token：

解释一下tokens是啥：tokens就是你向AI输入的字符数量和AI向你输出的字符数量，这里不一定是字符数量，具体还得看官方文档，我是按照自己理解来解释的，解释并不完全准确，不能作参考，如果有大佬知道，请麻烦告知！

紧接着就创建好了，箭头的地方就是model的代码，就是上面我们需要填写的东西，请不要泄露：

例如如果model的id是e0123i1jfkaoaw91212jk31，那么我们的代码应该为：

"model": "e0123i1jfkaoaw91212jk31"

然后，发送POST请求到API。

response = requests.post(url, headers=headers, json=data)

最后，打印响应内容。

print(response.json())

完整的代码（将上述代码组合在一起），如图所示：

import requests

url = "https://ark.cn-beijing.volces.com/api/v3/chat/completions"

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer ea764f0f-3b60-45b3-****-************"
}

data = {
    "model": "ep-20240704******-*****",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "Hello!"
        }
    ]
}

response = requests.post(url, headers=headers, json=data)

print(response.json())

第六步：运行脚本

这里很重要！！！请认真看：

在终端中输入python main.py即可运行，如果一切正常，你应该会在控制台看到API的响应JSON，如果一切正常，请往下继续读。如果提示API错误，请通过目录前往”SDK教学“板块处

第七步：处理用户输入

为了使聊天机器人更交互，我们可以让程序接受用户的输入，并将用户的提问发送到API。

使用input()函数获取用户输入。

将用户输入的内容动态地添加到请求数据中。

代码如下：

import requests

url = "https://ark.cn-beijing.volces.com/api/v3/chat/completions"

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer ea764f0f-3b60-45b3-****-************"
}

user_input = input("You: ")

data = {
    "model": "ep-20240704******-*****",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": user_input
        }
    ]
}

response = requests.post(url, headers=headers, json=data)

print("Assistant:", response.json()["choices"][0]["message"]["content"])

第九步：循环交互

为了使聊天机器人可以持续与用户交互，我们可以使用一个循环，不断接受用户输入并回复。

修改代码如下：

import requests

url = "https://ark.cn-beijing.volces.com/api/v3/chat/completions"

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer ea764f0f-3b60-45b3-****-************"
}

while True:
    user_input = input("You: ")
    if user_input.lower() in ['exit', 'quit']:
        break

    data = {
        "model": "ep-20240704******-*****",
        "messages": [
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": user_input
            }
        ]
    }

    response = requests.post(url, headers=headers, json=data)

    print("Assistant:", response.json()["choices"][0]["message"]["content"])

那么到这里，第一类调用API型AI教学已经完成了，最后在终端输入python main.py即可完成与AI对话功能，当然还能添加的功能还有许多，比如让AI记住上下文，比如优化代码结构，比如添加错误处理等等功能，这些只能靠你们自行学习咯。

SDK教学：

这一部分主要针对于上述方法不能响应API的JOSN的人，如果你上述操作可实现，请跳过这一步

如果你并没有实现上述操作，请删除全部代码，进行SDK的学习！

因为豆包本身提供了SDK用法，所以使API调用会更加简单方便，请根据图片点击进入：

进入后内部会有代码以供参考，我们现在以这些代码为例，实现调用API来创建对话AI

第一步：安装豆包的Python SDK

为了简化与豆包API的交互，我们将使用豆包提供的官方Python SDK。在PyCharm的终端中，运行以下命令来安装SDK：

请在pycharm的终端中输入代码，以安装SDK：

pip install --upgrade 'volcengine-python-sdk[ark]'

第二步：编写代码与豆包API交互

第一步：配置环境变量

1. 如果你是windows用户，打开命令提示符，输入以下命令：

setx ARK_API_KEY "YOUR_API_KEY_HERE"

命令提示符开启教程：

按下win+R键运行对话框，输入cmd点击确认

然后在命令提示符中输入如图所示代码，上面的那个代码，其中YOUR_API_KEY_HERE替换为你在豆包申请的API_KEY，然后回车，就可以完成环境变量配置：

完成后，为了确保环境变量已经正确设置，在命令提示符中输入：

echo %ARK_API_KEY%

如果设置成功，会显示你的API密钥

注意事项：

setx 命令设置的环境变量是持久化的，意味着它会一直存在，直到你手动删除或修改它。

如果你已经在命令提示符中设置了环境变量，可能需要重新启动PyCharm或任何其他依赖该环境变量的程序，以使更改生效。

2. 如果你是macOS或Linux用户

在终端输入以下指令即可：

export ARK_API_KEY=YOUR_API_KEY_HERE

第二步：写代码咯

首先确认你的pycharm重启了没，没重启的话，重启一下记得

接下来的代码，是豆包官方提供的，调用API的写法，但我做了一些修改，如果需要完全按照豆包的写法，请查看豆包的文档。

注意：

其中ARK_API_KEY不需要手动填入，因为已经在环境变量处理好了（环境变量比硬编码安全很多，可以多了解了解这个）

其中model内部的”------------------------“替换为你的model的id，上文提及

from volcenginesdkarkruntime import Ark
import os

# 设置API密钥从环境变量中获取
api_key = os.environ.get("ARK_API_KEY")
if not api_key:
    raise ValueError("API Key not found in environment variables")

# 初始化客户端
client = Ark(
    api_key=api_key,
    base_url="https://ark.cn-beijing.volces.com/api/v3"
)

def get_assistant_response(messages):
    try:
        response = client.chat.completions.create(
            model="------------",
            messages=messages
        )
        return response.choices[0].message.content
    except Exception as e:
        print("An error occurred:", e)
        return None

def main():
    conversation_history = [
        {
            "role": "system",
            "content": "你是豆包，是由字节跳动开发的 AI 人工智能助手"
        }
    ]

    while True:
        user_input = input("You: ")
        if user_input.lower() in ['exit', 'quit']:
            break

        conversation_history.append({
            "role": "user",
            "content": user_input
        })

        assistant_response = get_assistant_response(conversation_history)
        if assistant_response:
            print("Assistant:", assistant_response)
            conversation_history.append({
                "role": "assistant",
                "content": assistant_response
            })

if __name__ == "__main__":
    main()

第三步：运行程序

在终端输入python main.py即可运行程序，运行成功后是这样的，如图：

这就是一个与AI交互的窗口，例如我们问AI问题：

退出按crtl+c即可

那么到这里，你已经学完全部调用API的教学内容啦，恭喜你创建了一个可以对话的AI，当然如果你想了解更多，可以学习前端，后端，等等，以做出更多功能，优化用户体验，例如这是我的AI：

恭喜你做出了可以对话的AI哦~

第二类型AI教学（自己训练模型）：

自己训练的AI好处很多，可以按照自己的需求，训练AI，例如我想做一个专注于算法与编程类型的AI，我可以一直让AI训练我给它的有关算法和竞赛的类容

当然，上面是调用API，我们只是完成了自己创作一个可以对话的AI，但是大模型并不是我们自己做的，大模型仍然是官方的AI模型，但是从此开始，我们也可以自行训练自己的AI模型了，从本地部署属于自己的AI模型。在这里，我们完全不需要调用API，但是对我们的设备要求比较高。

为了方便教学与训练AI模型，我们在这里使用Hugging Face的Transformers库中预训练的BERT模型之一bert-base-chinese，这是预训练语言模型，针对于中文文本训练，我们将在此让它进行深度学习！

第一步：准备工作：

第一步：

安装Linux系统，运行UBuntu 64。此系统可以用虚拟机运行。如何安装，请从以下链接前往一个大佬的安装教程，这位大佬很强，一定要按照步骤来：

基于VMware虚拟机的Ubuntu22.04系统安装和配置（新手保姆级教程）-CSDN博客

第二步：

我们打开如图所示的方框，这个是应用商店：

然后在应用商店中搜索pycharm，选择如图所示的社区版(pycharm community)：

第三步：

打开pycharm并且创建一个新项目，项目名称自定义

①：选择自定义环境

②：选择如图所示环境类型，用于创建虚拟环境

③：这个地方点击右侧向下的小箭头，可以下载python，选择最新版就好啦。如果下载不下来的，请看后文教学。

注意：侧边栏和我的版本不一样可以不用在意，因为我的是专业版，与社区版不同

如果python下载不下来的解决办法：

打开你的终端（这里与win不同，这里是按crtl+alt+t），打开后向终端输入，然后回车安装即可：

sudo apt install python3-pip

安装完成后可以通过安装记录查看位置，一般情况下，pycharm会自动识别位置的

第四步：

点开页面左上角浏览器，搜索网址GitCode - 全球开发者的开源社区,开源代码托管平台

然后下载如图所示文件，一定要记住文件的位置，这个是预训练模型（对计算机配置要求不高），为了方便我们更好训练AI，如果你想使用其它预训练模型，可以去各大官网，例如阿里云，豆包等等都有提供。

到此为止，准备工作已经完成，恭喜你！

第二步：安装所需库

安装pandas库:

作用：主要用于数据处理和分析，能方便地读取、操作和分析结构化数据。在 load_data 函数里，使用 pd.read_csv 来读取 csv 格式的数据文件，将数据提取出来并进行后续处理，例如提取 questions 和 answers 列的数据。

请在如图所示的终端中输入以下代码，然后点击回车运行：

pip install pandas

出现像我这样的说明安装成功了，如果有notice提示，说明pip版本过低，像我一样把绿色字复制粘贴到下面，然后回车即可更新版本：

安装transformers库:

作用：提供了众多预训练的自然语言处理模型以及相关工具，方便进行文本处理、模型加载等操作。
BertTokenizer：用于对文本进行分词、编码等操作，比如将输入的文本（问题和答案等）转化为模型能够处理的 input_ids 等格式。在多个函数中都有使用，像 preprocess_data 函数里用它对问题和答案进行编码处理，以及在 answer_question 函数中对输入的提问进行编码。
BertForQuestionAnswering：这是基于 Bert 架构用于问答任务的预训练模型类，在代码中用于加载预训练模型（从指定路径或者默认的预训练模型名称加载），然后进行训练以及后续的推理回答问题。
Trainer 和 TrainingArguments：TrainingArguments 用于配置训练相关的参数，例如训练的轮数、批次大小、学习率相关的参数等；Trainer 则是基于给定的模型、训练数据集以及配置参数等进行模型训练的工具类，大大简化了训练流程。

在终端输入以下代码并回车以安装transformers库：

pip install transformers

安装torch库：

作用：是一个深度学习框架，提供了张量操作、自动求导等功能，支持构建和训练神经网络等操作。在代码中用于创建数据集类（torch.utils.data.Dataset 被继承来定义 QADataset 类，处理数据的索引、长度等操作），对数据进行张量转换（例如将数据转化为 torch.tensor 类型），在模型训练过程中传递数据，以及在推理阶段处理模型输出的结果（如通过 torch.argmax 来获取得分最高的索引等操作）。

这个库比较大，安装起来会比较慢，请耐心等待，如果你的电脑GPU支持的话，想使用GPU加速，可以安装GPU版本，用以下代码：

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

如果你只想安装CPU版本，请用以下代码：

pip install torch

那么到这里，所需要的库已经全部安装完毕啦

第三步：组装文件

找到我们刚刚下载好的预训练模型文件，然后在项目下创建一个bert-base-chinese文件夹，把文件一整个放入我们的项目中，如图所示：

完成后应该有如图所示这样：

第四步：代码编写

第一步：创建data_processing.py

在项目下创建一个文件，例如data_processing.py，如图所示：

①：右键项目文件，然后选择创建python文件

②输入data_processing然后回车即可，无需加后缀.py，这个是pycharm会自动加的

improt部分：

在文件中输入以下代码，用于引用各种库，库的用法在上文已经提及，如图所示：

import os
import pandas as pd
from transformers import BertTokenizer
import torch

QADataset类：

为了支持我们的AI可以进行问答作用，我们要写QA（question answer）类的代码，在这里我不作具体介绍，只简单介绍并提供完整的代码。QA类支持数据整合与封装，支持按索引获取数据样本(这是__getitem__方法的作用)，支持提供数据集长度信息（这是__len__方法的作用）。

具体代码如下，如图所示：

class QADataset(torch.utils.data.Dataset):
    def __init__(self, encodings, start_positions, end_positions):
        self.encodings = encodings
        self.start_positions = start_positions
        self.end_positions = end_positions

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item['start_positions'] = torch.tensor(self.start_positions[idx])
        item['end_positions'] = torch.tensor(self.end_positions[idx])
        return item

    def __len__(self):
        return len(self.encodings['input_ids'])

load_data函数部分：

这个函数主要是用于加载数据，用于确定数据文件位置，读取数据文件内容，提取问答相关数据列，这里也不做过多解释，完整代码如下：

def load_data(file_path):
    current_dir = os.path.dirname(os.path.abspath(__file__))
    file_path = os.path.join(current_dir, 'data', 'qa_data.csv')
    data = pd.read_csv(file_path)
    questions = data['questions'].tolist()
    answers = data['answers'].tolist()
    return questions, answers

`preprocess_data` 函数：

这个函数用于在整个问答系统代码中对数据进行预处理，主要作用是文本编码，确定答案位置，返回预处理结果，这里不作过多解释，完整代码如下：

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')

def preprocess_data(questions, answers):
    encodings = tokenizer(questions, answers, padding='max_length', truncation=True, max_length=128, return_tensors='pt')
    start_positions = []
    end_positions = []
    for i in range(len(questions)):
        input_ids = encodings['input_ids'][i].tolist()
        answer_tokens = tokenizer.encode(answers[i], add_special_tokens=False)
        try:
            start_idx = input_ids.index(answer_tokens[0])
            end_idx = start_idx + len(answer_tokens) - 1
        except ValueError:
            start_idx = 0
            end_idx = 0
        start_positions.append(start_idx)
        end_positions.append(end_idx)
    return encodings, start_positions, end_positions

到此为止data_processing.py已经全部编写完毕，完整代码如下：

import os
import pandas as pd
from transformers import BertTokenizer
import torch

class QADataset(torch.utils.data.Dataset):
    def __init__(self, encodings, start_positions, end_positions):
        self.encodings = encodings
        self.start_positions = start_positions
        self.end_positions = end_positions

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item['start_positions'] = torch.tensor(self.start_positions[idx])
        item['end_positions'] = torch.tensor(self.end_positions[idx])
        return item

    def __len__(self):
        return len(self.encodings['input_ids'])

def load_data(file_path):
    current_dir = os.path.dirname(os.path.abspath(__file__))
    file_path = os.path.join(current_dir, 'data', 'qa_data.csv')
    data = pd.read_csv(file_path)
    questions = data['questions'].tolist()
    answers = data['answers'].tolist()
    return questions, answers

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')

def preprocess_data(questions, answers):
    encodings = tokenizer(questions, answers, padding='max_length', truncation=True, max_length=128, return_tensors='pt')
    start_positions = []
    end_positions = []
    for i in range(len(questions)):
        input_ids = encodings['input_ids'][i].tolist()
        answer_tokens = tokenizer.encode(answers[i], add_special_tokens=False)
        try:
            start_idx = input_ids.index(answer_tokens[0])
            end_idx = start_idx + len(answer_tokens) - 1
        except ValueError:
            start_idx = 0
            end_idx = 0
        start_positions.append(start_idx)
        end_positions.append(end_idx)
    return encodings, start_positions, end_positions

第二步：创建train_model.py文件

这个文件与上一个创建方法一样，也是创建在项目文件下。

improt语句部分：

用于导入用到的库

import torch
from transformers import BertForQuestionAnswering, Trainer, TrainingArguments
from data_processing import QADataset, load_data, preprocess_data

数据准备部分：

这一部分顾名思义，用来准备数据的，主要调用data_processing.py文件中的load_data函数来传入数据，数据来源于后面我们会创建的文件，还有作用是利用后面会创建的preprocess_data函数来对问题和答案进行预处理，最后利用QADataset类处理完之后训练完给模型。大致意思是这一部分是为了各种训练数据提供隧道，这里不过多解释，具体代码如下：

questions, answers = load_data('qa_data.csv')
encodings, start_positions, end_positions = preprocess_data(questions, answers)
dataset = QADataset(encodings, start_positions, end_positions)

模型加载与训练参数配置部分：

这一部分主要用于对模型的加载与训练参数的配置，举个例子，我们的预训练模型是bert-base-chinese，这是对电脑性要求不太高的预训练模型，当然我们也可以选择各大官方开源的模型，例如Qwen有些开源模型，但是有一些对电脑性能要求比较高。这些模型都是训练过的，我们对它进行我们自己的训练，这样就可以调整模型，逐渐往我们想要的模型发展。

设置的参数有许多，比如热身步骤次数，模型训练轮数，指定权重衰减值等等许多许多，甚至可以自己设置参数，然而这些参数对训练模型意义非常大，如果一个模型趋向于1+1=2，那么我们可以调整训练参数，使模型趋向于1+1=3，当然如果一个数据训练的越多，那么另一个数据的权重也会相对减少，模型的训练是相对的，这也就说明了为什么网上有不同的AI，有些专注于算法与编程，有些专注于逻辑推理，有些专注于大语言对话等等等等

具体代码如下：

model = BertForQuestionAnswering.from_pretrained('bert-base-chinese')

training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=4,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
)

模型训练与保存部分：

训练模型主要调用了库中的函数，这个函数是一种训练算法，比较难，有兴趣可以了解了解，这会对已经配置好的参数来训练模型，训练模型，训练结束后，会把训练好的模型存储在trained_model文件夹下

具体代码如下：

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)

trainer.train()

model.save_pretrained('./trained_model')

那么到此为止，我们的train_model.py文件已经全部编写完毕啦，完整代码如下：

import torch
from transformers import BertForQuestionAnswering, Trainer, TrainingArguments
from data_processing import QADataset, load_data, preprocess_data

questions, answers = load_data('qa_data.csv')
encodings, start_positions, end_positions = preprocess_data(questions, answers)
dataset = QADataset(encodings, start_positions, end_positions)

model = BertForQuestionAnswering.from_pretrained('bert-base-chinese')

training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=4,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)

trainer.train()

model.save_pretrained('./trained_model')

第三步：创建qa_system.py文件，具体方法与上文类似，创建在项目文件下

`import` 语句部分：

导入要利用的库，具体代码如下：

import os
import torch
from transformers import BertTokenizer, BertForQuestionAnswering

模型与 `tokenizer` 加载部分：

这一部分主要用于拼接语句：寻找对应的模型与加载对应的分词器和模型。

我们训练模型的时候，是把词句都拆解开了，当我们需要运用时，我们需要拼接模型，然后才能做出回答，这里我不作过多解释，如果你想了解AI的原理，请前往以下大佬的视频链接：

90分钟！清华博士带你一口气搞懂人工智能和神经网络_哔哩哔哩_bilibili

个人感觉这位清华博士大佬把人工智能的本质讲解的很到位，如果你看完了视频，我想问一个问题：人工智能真的会自己产生思想吗？

具体代码如下：

current_dir = os.path.dirname(os.path.abspath(__file__))
model_path = os.path.join(current_dir, 'trained_model')

tokenizer = BertTokenizer.from_pretrained(model_path)
model = BertForQuestionAnswering.from_pretrained(model_path)

`answer_question` 函数部分：

这一部分，会英文都可以看出来，这一部分用于与用用户交互，用户输入问题，然后AI做出一系列内部的反应，最后将输出回答，这里我不多说，具体代码如下：

def answer_question(question):
    input_ids = tokenizer.encode(question, add_special_tokens=True, return_tensors='pt')
    outputs = model(input_ids)
    start_scores = outputs.start_logits
    end_scores = outputs.end_logits
    start_index = torch.argmax(start_scores, dim=1).item()
    end_index = torch.argmax(end_scores, dim=1).item()
    if start_index < end_index and end_index < len(input_ids[0]):
        answer_tokens = input_ids[0][start_index:end_index+1]
        answer = tokenizer.decode(answer_tokens)
    else:
        answer = "无法找到答案"
    return answer

主程序部分（`if name == "main"` 部分）：

这里是很重要的部分，是整个程序运行的入口点，原理也很简单，具体代码如下：

if __name__ == "__main__":
    while True:
        try:
            question = input("你有什么问题？（输入'退出'结束）")
            if question.lower() == '退出':
                break
            answer = answer_question(question)
            print("答案:", answer)
        except UnicodeDecodeError:
            print("输入包含无法解码的字符，请输入有效的UTF-8编码文本。")

那么到这里就完成了qa_system.py的所有编写，完整代码如下：

import os
import torch
from transformers import BertTokenizer, BertForQuestionAnswering

current_dir = os.path.dirname(os.path.abspath(__file__))
model_path = os.path.join(current_dir, 'trained_model')

tokenizer = BertTokenizer.from_pretrained(model_path)
model = BertForQuestionAnswering.from_pretrained(model_path)

def answer_question(question):
    input_ids = tokenizer.encode(question, add_special_tokens=True, return_tensors='pt')
    outputs = model(input_ids)
    start_scores = outputs.start_logits
    end_scores = outputs.end_logits
    start_index = torch.argmax(start_scores, dim=1).item()
    end_index = torch.argmax(end_scores, dim=1).item()
    if start_index < end_index and end_index < len(input_ids[0]):
        answer_tokens = input_ids[0][start_index:end_index+1]
        answer = tokenizer.decode(answer_tokens)
    else:
        answer = "无法找到答案"
    return answer

if __name__ == "__main__":
    while True:
        try:
            question = input("你有什么问题？（输入'退出'结束）")
            if question.lower() == '退出':
                break
            answer = answer_question(question)
            print("答案:", answer)
        except UnicodeDecodeError:
            print("输入包含无法解码的字符，请输入有效的UTF-8编码文本。")

恭喜你已经完成了全部代码的编写！！！！！！！！！！！还差最后几步就完成啦！

第四步：创建train_model文件夹，以供训练模型

这一步很简单，在项目目录下创建一个train_model文件夹（这个是可以自定义的，但是要与你的train_model.py的名称一样）

创建方法如图所示，对项目文件右键，然后选择创建目录，目录名称为train_model：

下一步请你在你的bert-base-chinese文件中找到model.safetensors和vocab.txt文件，将这两个文件移入train_model文件夹中，bert-base-chinese文件里面的可以不用删除，如果你是用的其它模型，其中也应该包含有这两个文件，如图所示：

第五步：创建data文件写入想训练的数据

创建方法与train_model一样，在项目文件目录下。

我们在data目录中创建一个qa_data.csv，如图所示：

注意：这次创建要写后缀.csv

在qa_data.csv中我们写入questions,anwsers，如下所示：

questions,answers

比如如果我们想要模型训练1+1=2，我们需要这样写：

左边是问题，右边是答案，这两边可以自行编写，用任何语言都可以，当然你的AI必须要先学会那门语言，而bert-base-chinese已经学会了汉语了。

注意：训练的问题至少写2行，封顶没有上限，写个千行万行都可以

现在已经完成所有文件和代码的编写了！！

第五步：训练模型与运行模型

训练模型：

我们要先配置好我们想让模型训练的文本，如图所示，我在qa_data.csv里让AI训练100次1+1=2，当然tran_model.py中的训练参数也是需要调的，比如循环次数选择5，那么就是训练500次：

然后在终端中输入以下命令：

python train_model.py

接下来它会开始训练模型，这个过程对电脑性能要求比较高：

训练完成后是这样的：

这里之后，会在你的目录中自动创建一个results文件夹，用于存储训练的数据

运行模型：

在训练完之后，在终端输入以下代码即可：

python qa_system.py

然后即可与你训练的AI进行交互，如下图：

可见AI并没有给出1+1=2，而是给出了1+1=？这是因为我们用的预训练模型，本身是已经训练过后的语言模型，里面的数据权重比较高，所有我们训练100次1+1=2，实际上是不够的，需要更多次数的训练，才能达到预期效果，还有一种情况是，这个预训练模型并不擅长数学，所以也要提前对齐进行数学符号与数学知识的运算，那么接下来就交给你们啦！！

第二类型自训练模型的教程到这里就结束啦！！