任务1: Masked LM

即随机屏蔽（masking）部分输入token，然后只预测那些被屏蔽的token。在模型中，随机地屏蔽了每个序列中15%的WordPiece token。
训练数据生成器随机选择15％的token。例如在这个句子“my dog is hairy”中，它选择的token是“hairy”。然后，执行以下过程：

数据生成器将执行以下操作，而不是始终用[MASK]替换所选单词：

80％的时间：用[MASK]标记替换单词，例如，my dog is hairy → my dog is [MASK]

10％的时间：用一个随机的单词替换该单词，例如，my dog is hairy → my dog is apple

10％的时间：保持单词不变，例如，my dog is hairy → my dog is hairy.
这样做的目的是将表示偏向于实际观察到的单词。

Transformer encoder不知道它将被要求预测哪些单词或哪些单词已被随机单词替换，因此它被迫保持每个输入token的分布式上下文表示。此外，因为随机替换只发生在所有token的1.5％（即15％的10％），这似乎不会损害模型的语言理解能力。

任务2：下一句预测

语料中50%的句子，选择其相应的下一句一起形成上下句，作为正样本；其余50%的句子随机选择一句非下一句一起形成上下句，作为负样本。而后进行训练，有利于sentence-level tasks，例如问答。

总的来说，BERT本质上是在海量语料的基础上，通过自监督学习的方法为单词学习一个好的特征表示。该模型的优点是可以根据具体的人物进行微调，或者直接使用预训练的模型作为特征提取器。

代码实现

model.py

预训练模型

1. https://huggingface.co/bert-base-chinese
2. 在我的资源里

模型

import torch.nn as nn
from transformers import BertModel
from config import parsers
import torch


class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.args = parsers()
        self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
        # 加载 bert 中文预训练模型
        self.bert = BertModel.from_pretrained(self.args.bert_pred)
        # 让 bert 模型进行微调（参数在训练过程中变化）
        for param in self.bert.parameters():
            param.requires_grad = True
        # 全连接层
        self.linear = nn.Linear(self.args.num_filters, self.args.class_num)

    def forward(self, x):
        input_ids, attention_mask = x[0].to(self.device), x[1].to(self.device)
        hidden_out = self.bert(input_ids, attention_mask=attention_mask,
                               output_hidden_states=False)  # 控制是否输出所有encoder层的结果
        # shape (batch_size, hidden_size)  pooler_output -->  hidden_out[0]
        pred = self.linear(hidden_out.pooler_output)
        # 返回预测结果
        return pred

# bert的输出结果有四个维度： last_hidden_state：shape是(batch_size, sequence_length, hidden_size)，hidden_size=768,它是模型最后一层输出的隐藏状态。
# pooler_output：shape是(batch_size, hidden_size)，这是序列的第一个token(classification token)的最后一层的隐藏状态，它是由线性层和Tanh激活函数进一步处理的。
# （通常用于句子分类，至于是使用这个表示，还是使用整个输入序列的隐藏状态序列的平均化或池化，视情况而定）

# hidden_states：这是输出的一个可选项，如果输出，需要指定config.output_hidden_states=True,它也是一个元组，它的第一个元素是embedding，其余元素是各层的输出，每个元素的形状是(
# batch_size, sequence_length, hidden_size)
# attentions：这也是输出的一个可选项，如果输出，需要指定config.output_attentions=True, 它也是一个元组，它的元素是每一层的注意力权重，用于计算self-attention heads的加权平均值。

# cross_attentions：shape是(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)

# 我们是微调模式，需要获取bert最后一个隐藏层的输出输入到下一个全连接层，所以取第一个维度，也就是hiden_outputs[0]

这段代码定义了一个名为MyModel的深度学习模型，该模型是PyTorch的nn.Module的子类。这个模型使用了预训练的BERT模型，并在其基础上添加了一个全连接层进行分类。

在__init__方法中，首先调用了父类的初始化方法，然后定义了一些属性。self.args是一个解析器对象，它可能包含了一些模型的参数。self.device是一个字符串，表示模型运行的设备，如果有可用的CUDA设备，就使用第一个CUDA设备，否则使用CPU。

接着，加载了预训练的BERT模型。self.bert是一个BertModel对象，它是从self.args.bert_pred指定的路径加载的。然后，设置了BERT模型的所有参数的requires_grad属性为True，这意味着在训练过程中，BERT模型的参数会被更新。

然后，定义了一个全连接层self.linear，它的输入维度是self.args.num_filters，输出维度是self.args.class_num。这个全连接层将被用来将BERT模型的输出转换为分类预测。

在forward方法中，首先将输入数据x移动到指定的设备，然后将x分解为input_ids和attention_mask。接着，将这两个输入传递给BERT模型，得到隐藏状态hidden_out。然后，将hidden_out.pooler_output传递给全连接层，得到预测结果pred。最后，返回预测结果。

数据集

util.py

import os
from config import parsers
# transformer库是一个把各种预训练模型集成在一起的库，导入之后，你就可以选择性的使用自己想用的模型，这里使用的BERT模型。
# 所以导入了bert模型，和bert的分词器，这里是对bert的使用，而不是bert自身的源码。
from transformers import BertTokenizer
from torch.utils.data import Dataset, DataLoader
import torch


def read_data(file):
    # 读取文件
    all_data = open(file, "r", encoding="utf-8").read().split("\n")
    # 得到所有文本、所有标签、句子的最大长度
    texts, labels, max_length = [], [], []
    for data in all_data:
        if data:
            text, label = data.split("\t")
            max_length.append(len(text))
            texts.append(text)
            labels.append(label)
    # 根据不同的数据集返回不同的内容
    if os.path.split(file)[1] == "train.txt":
        max_len = max(max_length)
        return texts, labels, max_len
    return texts, labels,


class MyDataset(Dataset):
    def __init__(self, texts, labels, max_length):
        self.all_text = texts
        self.all_label = labels
        self.max_len = max_length
        self.tokenizer = BertTokenizer.from_pretrained(parsers().bert_pred)

    def __getitem__(self, index):
        # 取出一条数据并截断长度
        text = self.all_text[index][:self.max_len]
        label = self.all_label[index]

        # 分词
        text_id = self.tokenizer.tokenize(text)
        # 加上起始标志
        text_id = ["[CLS]"] + text_id

        # 编码
        token_id = self.tokenizer.convert_tokens_to_ids(text_id)
        # 掩码  -》
        mask = [1] * len(token_id) + [0] * (self.max_len + 2 - len(token_id))
        # 编码后  -》长度一致
        token_ids = token_id + [0] * (self.max_len + 2 - len(token_id))
        # str -》 int
        label = int(label)

        # 转化成tensor
        token_ids = torch.tensor(token_ids)
        mask = torch.tensor(mask)
        label = torch.tensor(label)

        return (token_ids, mask), label

    def __len__(self):
        # 得到文本的长度
        return len(self.all_text)


if __name__ == "__main__":
    train_text, train_label, max_len = read_data("./data/train.txt")
    print(train_text[0], train_label[0])
    trainDataset = MyDataset(train_text, train_label, max_len)
    trainDataloader = DataLoader(trainDataset, batch_size=3, shuffle=False)
    for batch_text, batch_label in trainDataloader:
        print(batch_text, batch_label)

这段代码主要包含两个部分：一个是read_data函数，用于读取和处理数据；另一个是MyDataset类，用于创建PyTorch的数据集。

read_data函数接收一个文件路径作为参数，然后读取该文件中的所有数据。数据文件中的每一行都包含一个文本和一个标签，它们之间用制表符\t分隔。函数首先将文件中的所有数据读取到一个列表中，然后遍历这个列表，对每一行数据进行处理。处理的过程中，会将文本和标签分别添加到texts和labels两个列表中，同时计算每个文本的长度，并将长度添加到max_length列表中。如果数据文件是训练数据，函数还会计算出所有文本的最大长度max_len，然后返回texts、labels和max_len；如果数据文件不是训练数据，函数只返回texts和labels。

MyDataset类是PyTorch的Dataset类的子类，用于创建数据集。在初始化方法中，接收文本、标签和最大长度作为参数，并将它们保存为实例属性。然后，创建一个BERT分词器，用于将文本分词和编码。在__getitem__方法中，接收一个索引，然后返回该索引对应的数据和标签。数据的处理过程包括：截断文本、分词、添加起始标志、编码、创建掩码、将标签转换为整数、将数据和标签转换为张量。在__len__方法中，返回数据集中的文本数量。

这段代码的最后部分是一个测试代码，用于测试read_data函数和MyDataset类的功能。首先，使用read_data函数读取训练数据，然后使用MyDataset类创建数据集，接着创建一个数据加载器，最后遍历数据加载器，打印出每个批次的数据和标签。

配置

config.py

import argparse
import os.path


def parsers():
    parser = argparse.ArgumentParser(description="Bert model of argparse")
    parser.add_argument("--train_file", type=str, default=os.path.join("D:\PycharmProjects\Multimodal emotion/dataset/text", "train.txt"))
    parser.add_argument("--dev_file", type=str, default=os.path.join("D:\PycharmProjects\Multimodal emotion/dataset/text", "valid.txt"))
    parser.add_argument("--test_file", type=str, default=os.path.join("D:\PycharmProjects\Multimodal emotion/dataset/text", "test.txt"))
    parser.add_argument("--classification", type=str, default=os.path.join("D:\PycharmProjects\Multimodal emotion/dataset/text", "class.txt"))
    parser.add_argument("--bert_pred", type=str, default="D:\PycharmProjects\Multimodal emotion/model/bert-base-chinese")
    parser.add_argument("--class_num", type=int, default=3)
    parser.add_argument("--max_len", type=int, default=47)
    parser.add_argument("--batch_size", type=int, default=32)
    parser.add_argument("--epochs", type=int, default=10)
    parser.add_argument("--learn_rate", type=float, default=1e-5)
    parser.add_argument("--num_filters", type=int, default=768)
    parser.add_argument("--save_model_best", type=str, default=os.path.join("D:\PycharmProjects\Multimodal emotion\output/text/bert/model", "best_model.pth"))
    parser.add_argument("--save_model_last", type=str, default=os.path.join("D:\PycharmProjects\Multimodal emotion\output/text/bert/model", "last_model.pth"))
    args = parser.parse_args()
    return args

这段代码定义了一个名为parsers的函数，该函数使用argparse库来解析命令行参数。这些参数包括训练、验证和测试数据的文件路径，BERT预训练模型的路径，分类的数量，最大文本长度，批次大小，训练周期数，学习率，BERT模型的过滤器数量，以及最佳模型和最后模型的保存路径。

在函数中，首先创建了一个argparse.ArgumentParser对象，然后使用add_argument方法添加了一系列的命令行参数。每个参数都有一个名称，一个类型，以及一个默认值。例如，"–train_file"参数的类型是字符串，其默认值是训练数据的文件路径。

在添加完所有参数后，使用parse_args方法解析命令行参数，并将结果保存在args变量中。最后，函数返回args变量。

这种方式的好处是，可以在命令行中方便地指定或更改参数，而无需修改代码。此外，argparse库还提供了一些其他功能，如生成帮助和使用消息，处理错误等。

训练

main.py

import torch
from utils import read_data, MyDataset
from config import parsers
from torch.utils.data import DataLoader
from model import MyModel
from torch.optim import AdamW
import torch.nn as nn
from sklearn.metrics import accuracy_score
import time
from test import test_data
from tqdm import tqdm

if __name__ == "__main__":
    start = time.time()
    args = parsers()

    device = "cuda:0" if torch.cuda.is_available() else "cpu"

    train_text, train_label, max_len = read_data(args.train_file)
    dev_text, dev_label = read_data(args.dev_file)
    args.max_len = max_len

    train_dataset = MyDataset(train_text, train_label, args.max_len)
    train_dataloader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)

    dev_dataset = MyDataset(dev_text, dev_label, args.max_len)
    dev_dataloader = DataLoader(dev_dataset, batch_size=args.batch_size, shuffle=False)

    model = MyModel().to(device)
    opt = AdamW(model.parameters(), lr=args.learn_rate)
    loss_fn = nn.CrossEntropyLoss()

    acc_max = float("-inf")
    for epoch in range(args.epochs):
        print(f"Epoch {epoch + 1}")
        loss_sum, count = 0, 0
        model.train()
        for batch_index, (batch_text, batch_label) in enumerate(tqdm(train_dataloader)):
            batch_label = batch_label.to(device)
            pred = model(batch_text)

            loss = loss_fn(pred, batch_label)
            opt.zero_grad()
            loss.backward()
            opt.step()
            loss_sum += loss
            count += 1

        model.eval()
        all_pred, all_true = [], []
        with torch.no_grad():
            for batch_text, batch_label in tqdm(dev_dataloader):
                batch_label = batch_label.to(device)
                pred = model(batch_text)

                pred = torch.argmax(pred, dim=1).cpu().numpy().tolist()
                label = batch_label.cpu().numpy().tolist()

                all_pred.extend(pred)
                all_true.extend(label)

        acc = accuracy_score(all_pred, all_true)
        print(f"dev acc:{acc:.4f}")
        if acc > acc_max:
            print(acc, acc_max)
            acc_max = acc
            torch.save(model.state_dict(), args.save_model_best)
            print(f"以保存最佳模型")

    torch.save(model.state_dict(), args.save_model_last)

    end = time.time()
    print(f"运行时间：{(end-start)/60%60:.4f} min")
    test_data()

这段代码是一个深度学习模型的训练过程。首先，导入了所需的库和模块，包括PyTorch、数据处理函数、配置解析函数、数据加载器、模型、优化器、损失函数、评估指标等。

在主函数中，首先获取了当前时间，用于计算整个训练过程的运行时间。然后，调用parsers函数解析命令行参数，并将结果保存在args变量中。接着，检查是否有可用的CUDA设备，如果有，就使用第一个CUDA设备，否则使用CPU。

然后，使用read_data函数读取训练数据和验证数据，并将最大文本长度保存在args.max_len中。接着，使用MyDataset类创建训练数据集和验证数据集，然后使用DataLoader类创建对应的数据加载器。

接着，创建了一个MyModel模型，并将其移动到指定的设备。然后，创建了一个AdamW优化器，用于更新模型的参数。同时，定义了一个交叉熵损失函数。

然后，进入训练循环。在每个训练周期中，首先将模型设置为训练模式，然后遍历训练数据加载器，对每个批次的数据进行处理。处理的过程包括：将标签移动到指定的设备，将数据传递给模型得到预测结果，计算损失，清空优化器的梯度，反向传播，更新参数，累加损失。

在每个训练周期结束后，将模型设置为评估模式，然后遍历验证数据加载器，对每个批次的数据进行处理。处理的过程包括：将标签移动到指定的设备，将数据传递给模型得到预测结果，将预测结果和标签转换为列表，然后添加到总的预测结果和真实标签中。最后，计算验证集的准确率，如果准确率超过之前的最高准确率，就保存模型。

在所有训练周期结束后，保存最后的模型，然后计算并打印出整个训练过程的运行时间。最后，调用test_data函数进行测试。

评估

test.py

import torch
from tqdm import tqdm
from utils import read_data, MyDataset
from config import parsers
from torch.utils.data import DataLoader
from model import MyModel
from sklearn.metrics import accuracy_score
import numpy as np
import matplotlib.pyplot as plt

def max_iter(true_labels,predicted_labels):
    # 获取类别数量
    num_classes = max(max(true_labels), max(predicted_labels)) + 1

    # 计算混淆矩阵
    confusion_matrix = np.zeros((num_classes, num_classes), dtype=int)
    for true_label, predicted_label in zip(true_labels, predicted_labels):
        confusion_matrix[true_label][predicted_label] += 1

    # 类别标签
    labels = [f'Class {i}' for i in range(num_classes)]

    # 绘制混淆矩阵
    fig, ax = plt.subplots()
    im = ax.imshow(confusion_matrix, cmap='Blues')

    # 设置颜色条
    cbar = ax.figure.colorbar(im, ax=ax)

    # 设置标签
    ax.set(xticks=np.arange(num_classes),
        yticks=np.arange(num_classes),
        xticklabels=labels, yticklabels=labels,
        title='Confusion Matrix',
        ylabel='True label',
        xlabel='Predicted label')

    # 在矩阵方格中显示数值
    thresh = confusion_matrix.max() / 2.
    for i in range(num_classes):
        for j in range(num_classes):
            ax.text(j, i, format(confusion_matrix[i, j], 'd'),
                    ha="center", va="center",
                    color="white" if confusion_matrix[i, j] > thresh else "black")

    # 自动调整布局
    fig.tight_layout()
    plt.savefig("D:\PycharmProjects\Multimodal emotion\output/text/混淆矩阵.jpg")
    # 显示图形
    plt.show()

def test_data():
    args = parsers()
    device = "cuda:0" if torch.cuda.is_available() else "cpu"

    test_text, test_label = read_data(args.test_file)
    test_dataset = MyDataset(test_text, test_label, args.max_len)
    test_dataloader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False)

    model = MyModel().to(device)
    model.load_state_dict(torch.load(args.save_model_best))
    model.eval()

    all_pred, all_true = [], []
    with torch.no_grad():
        for batch_text, batch_label in tqdm(test_dataloader):
            
            batch_label, batch_label = batch_label.to(device), batch_label.to(device)
            pred = model(batch_text)
            pred = torch.argmax(pred, dim=1)
            
            pred = pred.cpu().numpy().tolist()
            label = batch_label.cpu().numpy().tolist()
            
            all_pred.extend(pred)
            all_true.extend(label)
    with open(".\output/test.txt", "w") as file:
        for item1, item2, item3 in zip(test_text, test_label,all_pred):
            file.write(f"{item1}\t{item2}\t{item3}\n")
            
    accuracy = accuracy_score(all_true, all_pred)

    print(f"test dataset accuracy:{accuracy:.4f}")
    max_iter(all_true,all_pred)


if __name__ == "__main__":
    test_data()

这段代码是一个深度学习模型的测试过程。首先，检查是否有可用的CUDA设备，如果有，就使用第一个CUDA设备，否则使用CPU。

然后，使用read_data函数读取测试数据，使用MyDataset类创建测试数据集，然后使用DataLoader类创建对应的数据加载器。

接着，创建了一个MyModel模型，并将其移动到指定的设备。然后，加载保存的最佳模型的参数，并将模型设置为评估模式。

然后，进入测试循环。在测试循环中，首先创建了两个空列表all_pred和all_true，用于保存所有的预测结果和真实标签。然后，遍历测试数据加载器，对每个批次的数据进行处理。处理的过程包括：将标签移动到指定的设备，将数据传递给模型得到预测结果，将预测结果的最大值的索引作为预测的类别，然后将预测结果和标签转换为列表，最后添加到总的预测结果和真实标签中。

在测试循环结束后，将测试文本、真实标签和预测结果写入到一个文本文件中。然后，计算测试集的准确率，并打印出来。最后，调用max_iter函数进行一些额外的处理。

预测

predict.py

from model import MyModel
from config import parsers
import torch
from transformers import BertTokenizer
import time
import csv
import pandas as pd

def write_to_csv(preds):
    # 读取已有的CSV文件
    df = pd.read_csv('predictions.csv')

    # 添加新的列
    df['bert'] = preds

    # 写入CSV文件
    df.to_csv('predictions.csv', index=False)

def load_model(device, model_path):
    myModel = MyModel().to(device)
    myModel.load_state_dict(torch.load(model_path))
    myModel.eval()
    return myModel


def process_text(text, bert_pred):
    tokenizer = BertTokenizer.from_pretrained(bert_pred)
    token_id = tokenizer.convert_tokens_to_ids(["[CLS]"] + tokenizer.tokenize(text))
    mask = [1] * len(token_id) + [0] * (args.max_len + 2 - len(token_id))
    token_ids = token_id + [0] * (args.max_len + 2 - len(token_id))
    token_ids = torch.tensor(token_ids).unsqueeze(0)
    mask = torch.tensor(mask).unsqueeze(0)
    x = torch.stack([token_ids, mask])
    return x


                    
def text_class_name(pred):
    result = torch.argmax(pred, dim=1)
    result = result.cpu().numpy().tolist()
    classification = open(args.classification, "r", encoding="utf-8").read().split("\n")
    classification_dict = dict(zip(range(len(classification)), classification))
    #print(f"文本：{text}\t预测的类别为：{classification_dict[result[0]]}")
    return result[0]
    
    
if __name__ == "__main__":
    # Convert integer values in preds to a list of lists
    
    start = time.time()
    args = parsers()
    device = "cuda:0" if torch.cuda.is_available() else "cpu"

    model = load_model(device, args.save_model_best)
    # 打开文件
    file = open("dataset\\text\\test.txt", "r", encoding="utf-8")

    # 按行读取文件内容
    lines = file.readlines()
    texts=[]
    # 处理每一行
    for line in lines:
        text, number = line.strip().split("\t")
        texts.append(text)
        # 现在，你可以使用text和number了

    # 关闭文件
    file.close()

    preds=[]

    print("模型预测结果：")
    for text in texts:
        x = process_text(text, args.bert_pred)
        with torch.no_grad():
            pred = model(x)
        
        d=text_class_name(pred)
        preds.append(int(d))
    end = time.time()
    
    write_to_csv(preds)
    print(f"耗时为：{end - start} s")
    

这段代码主要包含了三个函数：write_to_csv，load_model和process_text。

write_to_csv函数用于将预测结果写入到一个CSV文件中。首先，使用pandas的read_csv函数读取已有的CSV文件，并将结果保存在df变量中。然后，向df中添加一个新的列bert，其值为传入的预测结果preds。最后，使用to_csv函数将df写入到CSV文件中，其中index=False表示不保存索引。

load_model函数用于加载预训练的模型。首先，创建一个MyModel模型，并将其移动到指定的设备。然后，使用load_state_dict函数加载保存的模型参数。最后，将模型设置为评估模式，并返回模型。

process_text函数用于处理文本数据。首先，使用BertTokenizer.from_pretrained函数加载预训练的BERT分词器。然后，使用分词器将文本分词，并添加[CLS]标记，然后将分词结果转换为对应的ID。接着，创建一个掩码列表mask，其长度与ID列表相同，值全为1，然后将其扩展到args.max_len + 2的长度，扩展部分的值为0。同时，将ID列表扩展到args.max_len + 2的长度，扩展部分的值为0。然后，将ID列表和掩码列表转换为张量，并增加一个维度。最后，使用torch.stack函数将ID张量和掩码张量堆叠起来，作为模型的输入。

结果