devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

自然语言处理前馈神经

作者：秋刀鱼在做梦 | 2024-07-15 08:07:25

赞

踩

自然语言处理前馈神经

1 自然语言处理前馈网络（Feed Forward Neural Network，FNN）

  前馈神经网络（Feedforward Neural Network，简称FFNN）是一种基本的人工神经网络模型，广泛应用于自然语言处理和其他机器学习任务中。它的基本定义和工作原理如下：
一、定义
前馈神经网络是一种由多层神经元组成的神经网络，其中信息从输入层经过一层一层的隐藏层，最终到达输出层，每一层的神经元都与下一层的所有神经元相连，而各层之间没有反馈连接。每个神经元都通过一种激活函数（如ReLU、sigmoid、tanh等）处理其输入，以产生输出。
二、原理

1.输入层：接受输入数据的层。在自然语言处理中，输入可以是文本数据的词向量表示，或者是对文本进行编码后的特征向量。
2.隐藏层：中间层，通常由多个全连接层组成。每个隐藏层的神经元通过权重连接到上一层的所有神经元，并且每个神经元都应用一个激活函数来计算输出。隐藏层的数量和每个隐藏层的神经元数量是设计网络结构时的关键参数。
3.输出层：产生最终预测或输出的层。在自然语言处理中，输出可以是词汇表中的词语概率分布，也可以是某个标签的预测概率。
4.激活函数：每个神经元在接收到输入后，会先进行加权求和，然后通过一个激活函数来产生输出。常见的激活函数包括sigmoid函数、tanh函数和ReLU函数等，它们的选择会影响神经网络的性能和训练过程中的稳定性。
5.反向传播算法：用于训练前馈神经网络的主要算法是反向传播（Backpropagation）。它通过计算损失函数对每个权重的梯度，然后使用梯度下降法或其变种来更新网络中的权重，从而使得网络能够逐步优化和学习输入数据的模式。

三、在自然语言处理中的应用
前馈神经网络在自然语言处理中的应用非常广泛，例如：

1.文本分类：通过前馈神经网络可以对文本进行分类，比如情感分析、主题分类等。
2.命名实体识别：将文本中的命名实体（如人名、地名等）识别出来。
3.语言模型：预测下一个词的可能性，如机器翻译、语音识别等任务。
4.序列标注：如词性标注、命名实体识别等序列预测任务。

总之，前馈神经网络作为最基础和常见的神经网络模型之一，在自然语言处理中发挥着重要作用，为处理和理解文本数据提供了有效的工具和方法。

2 The Multilayer Perceptron（多层感知器）

  多层感知器（Multilayer Perceptron，MLP）是一种最基本和经典的前馈神经网络（Feedforward Neural Network，FFNN）模型。它由多个神经元层组成，包括输入层、至少一个或多个隐藏层以及一个输出层。MLP通常用于解决分类（Classification）和回归（Regression）问题，它具有以下特点和结构：
结构和特点

1.输入层（Input Layer）：输入层接受来自数据集的特征向量作为输入。每个特征通常是一个实数值，可以是原始特征或者经过特征工程处理得到的。


2.隐藏层（Hidden Layers）：MLP至少包含一个或多个隐藏层。每个隐藏层由多个神经元组成，每个神经元接收前一层的所有神经元的输出，并通过加权求和后应用一个激活函数来计算输出。每个隐藏层可以有不同数量的神经元，这是设计MLP时需要调整的一个重要超参数。


3.输出层（Output Layer）：输出层生成MLP的最终输出。根据任务的不同，输出层可以有一个神经元（用于二元分类）、多个神经元（用于多类分类），或者连续值（用于回归任务）。


4.激活函数（Activation Functions）：在每个神经元中，通常会使用非线性激活函数（如ReLU、sigmoid、tanh等）来引入非线性特性，使得网络能够学习更复杂的模式和特征。


5.反向传播算法（Backpropagation）：MLP的训练通常使用反向传播算法。该算法通过计算损失函数对网络中所有参数（权重和偏置）的梯度，并利用梯度下降法或其变种来更新参数，以最小化损失函数。

应用和优势

1.广泛应用：MLP在各种机器学习任务中广泛应用，包括图像分类、语音识别、自然语言处理、推荐系统等。
2.非线性能力：多层结构和非线性激活函数使得MLP能够捕捉和表达复杂的数据模式，比如在自然语言处理中处理非线性关系和序列数据。
3.可扩展性：MLP的结构可以扩展到更深的层次和更大的规模，使其在处理大规模数据和复杂任务时仍然有效。

总之，多层感知器（MLP）作为前馈神经网络的一种典型形式，为解决各种机器学习问题提供了一种有效的方法和工具。

2.1感知器和MLP学习的XOR问题的解决方案显示

我们在一个二元分类任务中训练感知器和MLP:每个数据点是一个二维坐标。在不深入研究实现细节的情况下，最终的模型预测如图4-3所示。在这个图中，错误分类的数据点用黑色填充，而正确分类的数据点没有填充。在左边的面板中，从填充的形状可以看出，感知器在学习一个可以将星星和圆分开的决策边界方面有困难。然而，MLP(右面板)学习了一个更精确地对星星和圆进行分类的决策边界。

2.2 PyTorch的一个实现

在PyTorch中，我们使用两个线性模块（通常被称为“完全连接层”或简称“fc层”）来构建一个简单的神经网络结构。这些线性层分别被命名为fc1和fc2。在fc1和fc2之间，我们引入了一个修正的线性单元（ReLU）作为非线性激活函数，它有助于模型学习复杂的非线性关系。为了保持网络结构的连贯性，必须确保fc1的输出特征数量与fc2的输入特征数量相匹配。这种层与层之间的连接确保了信息的有效传递。代码如下

  1. class MultilayerPerceptron(nn.Module):
  2.     def __init__(self, input_dim, hidden_dim, output_dim):
  3.         """
  4.         初始化多层感知机模型，包括两个全连接层。
  5.         
  6.         Args:
  7.             input_dim (int): 输入向量的大小
  8.             hidden_dim (int): 第一个线性层的输出大小
  9.             output_dim (int): 第二个线性层的输出大小
  10.         """
  11.         super(MultilayerPerceptron, self).__init__()
  12.         self.fc1 = nn.Linear(input_dim, hidden_dim)  # 第一个全连接层
  13.         self.fc2 = nn.Linear(hidden_dim, output_dim)  # 第二个全连接层
  14.  
  15.     def forward(self, x_in, apply_softmax=False):
  16.         """
  17.         多层感知机的前向传播过程。
  18.         
  19.         Args:
  20.             x_in (torch.Tensor): 输入数据张量。
  21.                 x_in.shape 应该是 (batch, input_dim)
  22.             apply_softmax (bool): softmax激活函数的标志
  23.                 如果与交叉熵损失一起使用，应为false
  24.         Returns:
  25.             结果张量。tensor.shape 应该是 (batch, output_dim)
  26.         """
  27.         intermediate = F.relu(self.fc1(x_in))  # 第一层全连接层经过ReLU激活函数处理
  28.         output = self.fc2(intermediate)  # 第二层全连接层
  29.  
  30.         if apply_softmax:
  31.             output = F.softmax(output, dim=1)  # 如果需要应用softmax激活函数，则进行softmax处理
  32.         return output
  33. batch_size = 2 # number of samples input at once
  34. input_dim = 3
  35. hidden_dim = 100
  36. output_dim = 4
  37.  
  38. # Initialize model
  39. mlp = MultilayerPerceptron(input_dim, hidden_dim, output_dim)
  40. print(mlp)

使用大小为3的输入维度、大小为4的输出维度和大小为100的隐藏维度。
结果如下：

在分类任务中，这些特征向量往往被解释为预测向量，它们表示了模型对于不同类别的预测概率分布。预测向量的后续处理取决于模型当前所处的阶段：训练或推理。在训练阶段，预测向量会与真实的目标类标签一起输入到损失函数中，以计算预测与实际之间的误差，从而指导模型的权重更新。而在推理或预测阶段，这些预测向量可能经过额外的处理（如选择最大概率的类别）以得到最终的预测结果。

3 带有多层感知器的姓氏分类

带有多层感知器（MLP）的姓氏分类是一个利用多层前馈神经网络来解决分类问题的应用实例。姓氏分类是一个典型的分类问题，目标是将给定的姓氏数据正确归类到相应的类别中。多层感知器（MLP）作为神经网络的一种，具有强大的非线性映射能力和学习能力，适合用于解决此类问题。

3.1数据集准备

姓氏数据集，它收集了来自18个不同国家的10,000个姓氏，这些姓氏是作者从互联网上不同的姓名来源收集的。该数据集将在本课程实验的几个示例中重用，并具有一些使其有趣的属性。第一个性质是它是相当不平衡的。排名前三的课程占数据的60%以上:27%是英语，21%是俄语，14%是阿拉伯语。剩下的15个民族的频率也在下降——这也是语言特有的特性。

数据收集：收集包含不同姓氏的数据集，每个姓氏都与一些特征相关联。在姓氏分类问题中，姓氏本身可能就是唯一的特征，但为了演示，可以假设有其他的辅助特征。

数据预处理：对收集到的数据进行预处理，包括缺失值填充、数据归一化等。归一化是将数据缩放到同一尺度，有助于加快模型的训练速度和提高性能。

数据划分：将数据集划分为训练集、验证集和测试集。通常，训练集用于训练模型，验证集用于调整超参数和评估模型性能测试集用于最终评估模型的泛化能力。

  1. class SurnameDataset(Dataset):
  2.     def __init__(self, surname_df, vectorizer):
  3.         """
  4.         参数:
  5.             surname_df (pandas.DataFrame): 数据集
  6.             vectorizer (SurnameVectorizer): 从数据集实例化的向量化器
  7.         """
  8.         self.surname_df = surname_df
  9.         self._vectorizer = vectorizer
  10.  
  11.         # 拆分数据集为训练集、验证集和测试集
  12.         self.train_df = self.surname_df[self.surname_df.split=='train']
  13.         self.train_size = len(self.train_df)
  14.  
  15.         self.val_df = self.surname_df[self.surname_df.split=='val']
  16.         self.validation_size = len(self.val_df)
  17.  
  18.         self.test_df = self.surname_df[self.surname_df.split=='test']
  19.         self.test_size = len(self.test_df)
  20.  
  21.         self._lookup_dict = {'train': (self.train_df, self.train_size),
  22.                              'val': (self.val_df, self.validation_size),
  23.                              'test': (self.test_df, self.test_size)}
  24.  
  25.         self.set_split('train')
  26.         
  27.         # 类别权重
  28.         class_counts = surname_df.nationality.value_counts().to_dict()
  29.         def sort_key(item):
  30.             return self._vectorizer.nationality_vocab.lookup_token(item[0])
  31.         sorted_counts = sorted(class_counts.items(), key=sort_key)
  32.         frequencies = [count for _, count in sorted_counts]
  33.         self.class_weights = 1.0 / torch.tensor(frequencies, dtype=torch.float32)
  34.  
  35.     @classmethod
  36.     def load_dataset_and_make_vectorizer(cls, surname_csv):
  37.         """加载数据集并从头创建一个新的向量化器
  38.         
  39.         参数:
  40.             surname_csv (str): 数据集的位置
  41.         返回:
  42.             SurnameDataset的一个实例
  43.         """
  44.         surname_df = pd.read_csv(surname_csv)
  45.         train_surname_df = surname_df[surname_df.split=='train']
  46.         return cls(surname_df, SurnameVectorizer.from_dataframe(train_surname_df))
  47.  
  48.     @classmethod
  49.     def load_dataset_and_load_vectorizer(cls, surname_csv, vectorizer_filepath):
  50.         """加载数据集和相应的向量化器。用于向量化器已被缓存以供重用的情况
  51.         
  52.         参数:
  53.             surname_csv (str): 数据集的位置
  54.             vectorizer_filepath (str): 已保存的向量化器的位置
  55.         返回:
  56.             SurnameDataset的一个实例
  57.         """
  58.         surname_df = pd.read_csv(surname_csv)
  59.         vectorizer = cls.load_vectorizer_only(vectorizer_filepath)
  60.         return cls(surname_df, vectorizer)
  61.  
  62.     @staticmethod
  63.     def load_vectorizer_only(vectorizer_filepath):
  64.         """从文件加载向量化器的静态方法
  65.         
  66.         参数:
  67.             vectorizer_filepath (str): 序列化向量化器的位置
  68.         返回:
  69.             SurnameVectorizer的一个实例
  70.         """
  71.         with open(vectorizer_filepath) as fp:
  72.             return SurnameVectorizer.from_serializable(json.load(fp))
  73.  
  74.     def save_vectorizer(self, vectorizer_filepath):
  75.         """使用json将向量化器保存到磁盘
  76.         
  77.         参数:
  78.             vectorizer_filepath (str): 保存向量化器的位置
  79.         """
  80.         with open(vectorizer_filepath, "w") as fp:
  81.             json.dump(self._vectorizer.to_serializable(), fp)
  82.  
  83.     def get_vectorizer(self):
  84.         """ 返回向量化器 """
  85.         return self._vectorizer
  86.  
  87.     def set_split(self, split="train"):
  88.         """ 使用数据框中的列选择数据集的拆分 """
  89.         self._target_split = split
  90.         self._target_df, self._target_size = self._lookup_dict[split]
  91.  
  92.     def __len__(self):
  93.         return self._target_size
  94.  
  95.     def __getitem__(self, index):
  96.         """PyTorch数据集的主要入口点方法
  97.         
  98.         参数:
  99.             index (int): 数据点的索引
  100.         返回:
  101.             一个包含数据点的字典:
  102.                 特征 (x_surname)
  103.                 标签 (y_nationality)
  104.         """
  105.         row = self._target_df.iloc[index]
  106.  
  107.         surname_vector = self._vectorizer.vectorize(row.surname)
  108.  
  109.         nationality_index = self._vectorizer.nationality_vocab.lookup_token(row.nationality)
  110.  
  111.         return {'x_surname': surname_vector,
  112.                 'y_nationality': nationality_index}
  113.  
  114.     def get_num_batches(self, batch_size):
  115.         """给定批量大小，返回数据集中的批次数量
  116.         
  117.         参数:
  118.             batch_size (int)
  119.         返回:
  120.             数据集中的批次数量
  121.         """
  122.         return len(self) // batch_size
  123.  
  124.     
  125. def generate_batches(dataset, batch_size, shuffle=True,
  126.                      drop_last=True, device="cpu"): 
  127.     """
  128.     一个包装PyTorch DataLoader的生成器函数。它将确保每个张量在正确的设备位置上。
  129.     """
  130.     dataloader = DataLoader(dataset=dataset, batch_size=batch_size,
  131.                             shuffle=shuffle, drop_last=drop_last)
  132.  
  133.     for data_dict in dataloader:
  134.         out_data_dict = {}
  135.         for name, tensor in data_dict.items():
  136.             out_data_dict[name] = data_dict[name].to(device)
  137.         yield out_data_dict
  138. class Vocabulary(object):
  139.     """用于处理文本并提取词汇以进行映射的类"""
  140.  
  141.     def __init__(self, token_to_idx=None, add_unk=True, unk_token="<UNK>"):
  142.         """
  143.         初始化Vocabulary实例。
  144.         参数:
  145.             token_to_idx (dict): 一个现有的将标记映射到索引的字典
  146.             add_unk (bool): 一个指示是否添加UNK标记的标志
  147.             unk_token (str): 要添加到词汇表中的UNK标记
  148.         """
  149.  
  150.         if token_to_idx is None:
  151.             token_to_idx = {}
  152.         self._token_to_idx = token_to_idx
  153.  
  154.         # 创建从索引到标记的反向映射
  155.         self._idx_to_token = {idx: token for token, idx in self._token_to_idx.items()}
  156.         
  157.         self._add_unk = add_unk
  158.         self._unk_token = unk_token
  159.         
  160.         self.unk_index = -1
  161.         # 如果要求，将UNK标记添加到词汇表中
  162.         if add_unk:
  163.             self.unk_index = self.add_token(unk_token) 
  164.         
  165.     def to_serializable(self):
  166.         """返回一个可序列化的字典。"""
  167.         return {'token_to_idx': self._token_to_idx, 
  168.                 'add_unk': self._add_unk, 
  169.                 'unk_token': self._unk_token}
  170.  
  171.     @classmethod
  172.     def from_serializable(cls, contents):
  173.         """从序列化字典实例化Vocabulary。"""
  174.         return cls(**contents)
  175.  
  176.     def add_token(self, token):
  177.         """基于标记更新映射字典。
  178.         参数:
  179.             token (str): 要添加到Vocabulary中的项
  180.         返回:
  181.             index (int): 对应于标记的整数
  182.         """
  183.         try:
  184.             index = self._token_to_idx[token]
  185.         except KeyError:
  186.             index = len(self._token_to_idx)
  187.             self._token_to_idx[token] = index
  188.             self._idx_to_token[index] = token
  189.         return index
  190.     
  191.     def add_many(self, tokens):
  192.         """将标记列表添加到Vocabulary中。
  193.         
  194.         参数:
  195.             tokens (list): 字符串标记列表
  196.         返回:
  197.             indices (list): 与标记对应的索引列表
  198.         """
  199.         return [self.add_token(token) for token in tokens]
  200.  
  201.     def lookup_token(self, token):
  202.         """检索与标记相关联的索引，如果标记不存在，则使用UNK索引。
  203.         
  204.         参数:
  205.             token (str): 要查找的标记
  206.         返回:
  207.             index (int): 与标记相关的索引
  208.         注意:
  209.             UNK功能需要unk_index >= 0（已添加到Vocabulary中）
  210.         """
  211.         if self.unk_index >= 0:
  212.             return self._token_to_idx.get(token, self.unk_index)
  213.         else:
  214.             return self._token_to_idx[token]
  215.  
  216.     def lookup_index(self, index):
  217.         """返回与索引相关联的标记。
  218.         
  219.         参数: 
  220.             index (int): 要查找的索引
  221.         返回:
  222.             token (str): 与索引相关的标记
  223.         引发:
  224.             KeyError: 如果索引不在Vocabulary中
  225.         """
  226.         if index not in self._idx_to_token:
  227.             raise KeyError("索引(%d)不在Vocabulary中" % index)
  228.         return self._idx_to_token[index]
  229.  
  230.     def __str__(self):
  231.         """返回Vocabulary的字符串表示形式。"""
  232.         return "<Vocabulary(size=%d)>" % len(self)
  233.  
  234.     def __len__(self):
  235.         """返回Vocabulary中唯一标记的数量。"""
  236.         return len(self._token_to_idx)
  237. class SurnameVectorizer(object):
  238.     """协调Vocabularies并将它们应用于实际用途的向量化器"""
  239.  
  240.     def __init__(self, surname_vocab, nationality_vocab):
  241.         """
  242.         参数:
  243.             surname_vocab (Vocabulary): 将字符映射到整数的词汇表
  244.             nationality_vocab (Vocabulary): 将国籍映射到整数的词汇表
  245.         """
  246.         self.surname_vocab = surname_vocab
  247.         self.nationality_vocab = nationality_vocab
  248.  
  249.     def vectorize(self, surname):
  250.         """
  251.         将姓氏向量化为一种折叠的one-hot编码。
  252.         参数:
  253.             surname (str): 姓氏
  254.         返回:
  255.             one_hot (np.ndarray): 一个折叠的one-hot编码
  256.         """
  257.         vocab = self.surname_vocab
  258.         one_hot = np.zeros(len(vocab), dtype=np.float32)
  259.         for token in surname:
  260.             one_hot[vocab.lookup_token(token)] = 1
  261.  
  262.         return one_hot
  263.  
  264.     @classmethod
  265.     def from_dataframe(cls, surname_df):
  266.         """从数据集DataFrame实例化向量化器。
  267.         参数:
  268.             surname_df (pandas.DataFrame): 姓氏数据集
  269.         返回:
  270.             SurnameVectorizer的实例
  271.         """
  272.         surname_vocab = Vocabulary(unk_token="@")
  273.         nationality_vocab = Vocabulary(add_unk=False)
  274.  
  275.         for index, row in surname_df.iterrows():
  276.             for letter in row.surname:
  277.                 surname_vocab.add_token(letter)
  278.             nationality_vocab.add_token(row.nationality)
  279.  
  280.         return cls(surname_vocab, nationality_vocab)
  281.  
  282.     @classmethod
  283.     def from_serializable(cls, contents):
  284.         surname_vocab = Vocabulary.from_serializable(contents['surname_vocab'])
  285.         nationality_vocab = Vocabulary.from_serializable(contents['nationality_vocab'])
  286.         return cls(surname_vocab=surname_vocab, nationality_vocab=nationality_vocab)
  287.  
  288.     def to_serializable(self):
  289.         """返回一个可序列化的字典。"""
  290.         return {'surname_vocab': self.surname_vocab.to_serializable(),
  291.                 'nationality_vocab': self.nationality_vocab.to_serializable()}

3.2构建多层感知器模型

构建一个多层感知器（MLP）模型涉及以下几个关键步骤：
1. 数据准备
首先，准备数据集，确保数据集包含输入特征和相应的标签。数据应该被分成训练集、验证集和测试集。
2. 定义模型结构
MLP是一种前馈神经网络，由多个层组成：输入层、多个隐藏层和输出层。每一层都由神经元组成，每个神经元与前一层的所有神经元连接，每个连接有一个权重。以下是构建MLP模型的关键组成部分：

1.输入层：输入层神经元数等于特征向量的维度。
2.隐藏层：可以有一个或多个隐藏层，每个隐藏层包含多个神经元。隐藏层的选择通常依赖于数据的复杂性和问题的特征。每个隐藏层通常使用激活函数来引入非线性，如ReLU（Rectified Linear Unit）或sigmoid函数。
3.输出层：输出层的神经元数通常等于分类问题中的类别数量。对于多类别分类任务，输出层通常使用softmax激活函数，以输出每个类别的概率分布；对于二分类任务，可以使用sigmoid激活函数。

3. 模型构建
在构建模型时，可以使用深度学习框架如TensorFlow、PyTorch或Keras来简化实现过程。以下是使用Keras（TensorFlow的高级API）构建一个简单的MLP模型的示例：

  1. from keras.models import Sequential
  2. from keras.layers import Dense
  3.  
  4. # 定义模型
  5. model = Sequential()
  6.  
  7. # 添加输入层和第一个隐藏层
  8. model.add(Dense(units=64, activation='relu', input_dim=input_dim))
  9.  
  10. # 添加更多隐藏层
  11. model.add(Dense(units=64, activation='relu'))
  12.  
  13. # 添加输出层
  14. model.add(Dense(units=num_classes, activation='softmax'))
  15.  
  16. # 编译模型
  17. model.compile(loss='categorical_crossentropy',
  18.               optimizer='adam',
  19.               metrics=['accuracy'])
  20.  
  21. # 输出模型的结构
  22. model.summary()

在这个例子中：

4.Sequential模型允许按顺序添加层。
5.Dense层定义全连接层，units参数指定神经元数量，activation参数指定激活函数。
6.input_dim是输入数据的特征维度。
7.compile方法配置模型的学习过程，包括损失函数、优化器和评估指标。

4. 训练模型
使用准备好的训练数据对模型进行训练：
 

model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_val, y_val))

5. 模型评估和预测
训练完成后，使用测试数据集评估模型的性能，并使用模型进行预测：
 

  1. score = model.evaluate(X_test, y_test, batch_size=32)
  2. predictions = model.predict(X_new_data)

3.3训练模型

学习率调度器初始化：使用ReduceLROnPlateau调度器，当验证集上的性能（如损失）不再提升时，减少学习率。
初始化训练状态：创建一个字典train_state来存储训练过程中的状态信息。
进度条设置：使用tqdm库设置训练和验证过程的进度条，以便于监控训练进度。
训练循环：循环迭代args.num_epochs次，每次迭代代表一个训练周期。
训练数据集迭代：设置数据集为训练模式，创建批处理生成器，初始化损失和准确率，设置模型为训练模式。对于每个批次，执行以下步骤：计算准确率并更新进度条，更新优化器，进行梯度下降，计算损失并反向传播，计算模型输出y_pred，清零梯度。
验证数据集迭代：设置数据集为验证模式，创建批处理生成器，初始化损失和准确率，设置模型为评估模式。类似于训练数据集迭代，但不对模型参数进行更新，只计算损失和准确率。
更新训练状态：根据验证损失更新训练状态，可能包括早停（early stopping）等策略。
学习率调整：使用scheduler.step()根据验证损失调整学习率。
早停检查：如果满足早停条件，则退出训练循环。
进度条重置：重置训练和验证进度条的计数器。
异常处理：使用try-except结构来捕获KeyboardInterrupt，允许用户通过中断信号（如Ctrl+C）安全退出训练循环。

  1. scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
  2.                                                  mode='min', factor=0.5,
  3.                                                  patience=1)
  4. # 初始化训练状态
  5. train_state = make_train_state(args)
  6.  
  7. epoch_bar = tqdm(desc='training routine',   # 迭代轮次
  8.                  total=args.num_epochs,
  9.                  position=0)
  10.  
  11. dataset.set_split('train')
  12. train_bar = tqdm(desc='split=train',
  13.                  total=dataset.get_num_batches(args.batch_size), 
  14.                  position=1, 
  15.                  leave=True)
  16. dataset.set_split('val')
  17. val_bar = tqdm(desc='split=val',
  18.                total=dataset.get_num_batches(args.batch_size), 
  19.                position=1, 
  20.                leave=True)
  21.  
  22. try:
  23.     for epoch_index in range(args.num_epochs):
  24.         train_state['epoch_index'] = epoch_index
  25.  
  26.         # Iterate over training dataset
  27.  
  28.       
  29.         #  设置: 批处理生成器, 将损失和准确率设为0, 设置训练模式
  30.         dataset.set_split('train')
  31.         batch_generator = generate_batches(dataset, 
  32.                                            batch_size=args.batch_size, 
  33.                                            device=args.device)
  34.         running_loss = 0.0
  35.         running_acc = 0.0
  36.         classifier.train()
  37.  
  38.         for batch_index, batch_dict in enumerate(batch_generator):
  39.             # the training routine is these 5 steps:
  40.  
  41.             # --------------------------------------
  42.             # 步骤 1. 清零梯度
  43.             optimizer.zero_grad()
  44.  
  45.             # 计算输出
  46.             y_pred = classifier(batch_dict['x_surname'])
  47.  
  48.             #  计算损失
  49.             loss = loss_func(y_pred, batch_dict['y_nationality'])
  50.             loss_t = loss.item()
  51.             running_loss += (loss_t - running_loss) / (batch_index + 1)
  52.  
  53.           # 计算准确率
  54.             loss.backward()
  55.  
  56.             # step 5. use optimizer to take gradient step
  57.             optimizer.step()
  58.             # -----------------------------------------
  59.             # compute the accuracy
  60.             acc_t = compute_accuracy(y_pred, batch_dict['y_nationality'])
  61.             running_acc += (acc_t - running_acc) / (batch_index + 1)
  62.  
  63.             # update bar
  64.             train_bar.set_postfix(loss=running_loss, acc=running_acc, 
  65.                             epoch=epoch_index)
  66.             train_bar.update()
  67.  
  68.         train_state['train_loss'].append(running_loss)
  69.         train_state['train_acc'].append(running_acc)
  70.  
  71.         # Iterate over val dataset
  72.  
  73.         # setup: batch generator, set loss and acc to 0; set eval mode on
  74.         dataset.set_split('val')
  75.         batch_generator = generate_batches(dataset, 
  76.                                            batch_size=args.batch_size, 
  77.                                            device=args.device)
  78.         running_loss = 0.
  79.         running_acc = 0.
  80.         classifier.eval()
  81.  
  82.         for batch_index, batch_dict in enumerate(batch_generator):
  83.  
  84.             # 计算输出
  85.             y_pred =  classifier(batch_dict['x_surname'])
  86.  
  87.             #  计算损失
  88.             loss = loss_func(y_pred, batch_dict['y_nationality'])
  89.             loss_t = loss.to("cpu").item()
  90.             running_loss += (loss_t - running_loss) / (batch_index + 1)
  91.  
  92.              # 计算准确率
  93.             acc_t = compute_accuracy(y_pred, batch_dict['y_nationality'])
  94.             running_acc += (acc_t - running_acc) / (batch_index + 1)
  95.             val_bar.set_postfix(loss=running_loss, acc=running_acc, 
  96.                             epoch=epoch_index)
  97.             val_bar.update()
  98.  
  99.         train_state['val_loss'].append(running_loss)
  100.         train_state['val_acc'].append(running_acc)
  101.         
  102.           # 更新训练状态并根据验证损失调整学习率
  103.         train_state = update_train_state(args=args, model=classifier,
  104.                                          train_state=train_state)
  105.  
  106.         scheduler.step(train_state['val_loss'][-1])
  107.  
  108.         if train_state['stop_early']:
  109.             break
  110.  
  111.         train_bar.n = 0
  112.         val_bar.n = 0
  113.         epoch_bar.update()
  114. except KeyboardInterrupt:
  115.     print("Exiting loop")

训练过程展示：

3.4 应用模型

使用训练好的模型来预测新姓氏的分类。

  1. def predict_topk_nationality(name, classifier, vectorizer, k=5):
  2.     # 将名字向量化
  3.     vectorized_name = vectorizer.vectorize(name)
  4.     # 将向量转换为张量并调整形状
  5.     vectorized_name = torch.tensor(vectorized_name).view(1, -1)
  6.     # 使用分类器对名字进行预测，并应用softmax函数
  7.     prediction_vector = classifier(vectorized_name, apply_softmax=True)
  8.     # 获取前k个最大概率值和对应的索引
  9.     probability_values, indices = torch.topk(prediction_vector, k=k)
  10.  
  11.     # returned size is 1,k
  12.     # 将概率值和索引转换为numpy数组
  13.     probability_values = probability_values.detach().numpy()[0]
  14.     indices = indices.detach().numpy()[0]
  15.  
  16.     # 初始化结果列表
  17.     results = []
  18.     # 遍历概率值和索引，将民族和概率值添加到结果列表中
  19.     for prob_value, index in zip(probability_values, indices):
  20.         nationality = vectorizer.nationality_vocab.lookup_index(index)
  21.         results.append({'nationality': nationality,
  22.                         'probability': prob_value})
  23.  
  24.     return results
  25. # 输入要分类的姓氏
  26. new_surname = input("Enter a surname to classify: ")
  27.  
  28. # 将分类器移到CPU上
  29. classifier = classifier.to("cpu")
  30.  
  31. # 询问用户要显示的前k个预测结果
  32. k = int(input("How many of the top predictions to see? "))
  33. if k > len(vectorizer.nationality_vocab):
  34.     print("Sorry! That's more than the # of nationalities we have.. defaulting you to max size :)")
  35.     k = len(vectorizer.nationality_vocab)
  36.     
  37. # 调用函数进行预测
  38. predictions = predict_topk_nationality(new_surname, classifier, vectorizer, k=k)
  39.  
  40. # 打印前k个预测结果
  41. print("Top {} predictions:".format(k))
  42. print("===================")
  43. for prediction in predictions:
  44.     print("{} -> {} (p={:0.2f})".format(new_surname,
  45.                                         prediction['nationality'],
  46.                                         prediction['probability']))

4 使用卷积神经网络对姓氏进行分类（Convolutional Neural Network）

使用CNN对姓氏进行分类的优势在于其强大的特征提取能力，可以自动学习姓氏中的关键特征，而不需要手动设计特征。然而，对于文本数据，卷积神经网络可能不如循环神经网络（RNN）或Transformer等模型在处理序列数据方面灵活。不过，CNN在某些特定的文本分类任务中仍然表现出色。

  1. def make_train_state(args):
  2.     return {'stop_early': False,
  3.             'early_stopping_step': 0,
  4.             'early_stopping_best_val': 1e8,
  5.             'learning_rate': args.learning_rate,
  6.             'epoch_index': 0,
  7.             'train_loss': [],
  8.             'train_acc': [],
  9.             'val_loss': [],
  10.             'val_acc': [],
  11.             'test_loss': -1,
  12.             'test_acc': -1,
  13.             'model_filename': args.model_state_file}
  14. def update_train_state(args, model, train_state):
  15.     """Handle the training state updates.
  16.     Components:
  17.      - Early Stopping: Prevent overfitting.
  18.      - Model Checkpoint: Model is saved if the model is better
  19.     :param args: main arguments
  20.     :param model: model to train
  21.     :param train_state: a dictionary representing the training state values
  22.     :returns:
  23.         a new train_state
  24.     """
  25.  
  26.     # Save one model at least
  27.     if train_state['epoch_index'] == 0:
  28.         torch.save(model.state_dict(), train_state['model_filename'])
  29.         train_state['stop_early'] = False
  30.  
  31.     # Save model if performance improved
  32.     elif train_state['epoch_index'] >= 1:
  33.         loss_tm1, loss_t = train_state['val_loss'][-2:]
  34.  
  35.         # If loss worsened
  36.         if loss_t >= train_state['early_stopping_best_val']:
  37.             # Update step
  38.             train_state['early_stopping_step'] += 1
  39.         # Loss decreased
  40.         else:
  41.             # Save the best model
  42.             if loss_t < train_state['early_stopping_best_val']:
  43.                 torch.save(model.state_dict(), train_state['model_filename'])
  44.  
  45.             # Reset early stopping step
  46.             train_state['early_stopping_step'] = 0
  47.  
  48.         # Stop early ?
  49.         train_state['stop_early'] = \
  50.             train_state['early_stopping_step'] >= args.early_stopping_criteria
  51.  
  52.     return train_state
  53. def compute_accuracy(y_pred, y_target):
  54.     y_pred_indices = y_pred.max(dim=1)[1]
  55.     n_correct = torch.eq(y_pred_indices, y_target).sum().item()
  56.     return n_correct / len(y_pred_indices) * 100
  57. args = Namespace(
  58.     # 数据和路径信息
  59.     surname_csv="data/surnames/surnames_with_splits.csv",
  60.     vectorizer_file="vectorizer.json",
  61.     model_state_file="model.pth",
  62.     save_dir="model_storage/ch4/cnn",
  63.     # 模型超参数
  64.     hidden_dim=100,
  65.     num_channels=256,
  66.     # 训练超参数
  67.     seed=1337,
  68.     learning_rate=0.001,
  69.     batch_size=128,
  70.     num_epochs=100,
  71.     early_stopping_criteria=5,
  72.     dropout_p=0.1,
  73.     # 运行时选项
  74.     cuda=False,
  75.     reload_from_files=False,
  76.     expand_filepaths_to_save_dir=True,
  77.     catch_keyboard_interrupt=True
  78. )
  79.  
  80. # 如果需要将文件路径扩展到保存目录，则进行扩展
  81. if args.expand_filepaths_to_save_dir:
  82.     args.vectorizer_file = os.path.join(args.save_dir,
  83.                                         args.vectorizer_file)
  84.  
  85.     args.model_state_file = os.path.join(args.save_dir,
  86.                                          args.model_state_file)
  87.     
  88.     print("Expanded filepaths: ")
  89.     print("\t{}".format(args.vectorizer_file))
  90.     print("\t{}".format(args.model_state_file))
  91.     
  92. # 检查CUDA是否可用
  93. if not torch.cuda.is_available():
  94.     args.cuda = False
  95.  
  96. args.device = torch.device("cuda" if args.cuda else "cpu")
  97. print("Using CUDA: {}".format(args.cuda))
  98.  
  99. def set_seed_everywhere(seed, cuda):
  100.     np.random.seed(seed)
  101.     torch.manual_seed(seed)
  102.     if cuda:
  103.         torch.cuda.manual_seed_all(seed)
  104.         
  105. def handle_dirs(dirpath):
  106.     if not os.path.exists(dirpath):
  107.         os.makedirs(dirpath)
  108.         
  109. # 设置随机种子以确保可重复性
  110. set_seed_everywhere(args.seed, args.cuda)
  111.  
  112. # 处理目录
  113. handle_dirs(args.save_dir)
  114. if args.reload_from_files:
  115.     # 如果从文件中加载模型，则从检查点恢复训练
  116.     dataset = SurnameDataset.load_dataset_and_load_vectorizer(args.surname_csv,
  117.                                                               args.vectorizer_file)
  118. else:
  119.     # 否则，创建数据集和向量化器
  120.     dataset = SurnameDataset.load_dataset_and_make_vectorizer(args.surname_csv)
  121.     dataset.save_vectorizer(args.vectorizer_file)
  122.     
  123. # 获取向量化器
  124. vectorizer = dataset.get_vectorizer()
  125.  
  126. # 初始化分类器
  127. classifier = SurnameClassifier(initial_num_channels=len(vectorizer.surname_vocab), 
  128.                                num_classes=len(vectorizer.nationality_vocab),
  129.                                num_channels=args.num_channels)
  130.  
  131. # 将分类器移动到指定设备（CPU或GPU）
  132. classifer = classifier.to(args.device)
  133. # 将类别权重移动到指定设备（CPU或GPU）
  134. dataset.class_weights = dataset.class_weights.to(args.device)
  135.  
  136. # 定义损失函数，使用加权交叉熵损失
  137. loss_func = nn.CrossEntropyLoss(weight=dataset.class_weights)
  138. # 定义优化器，使用Adam算法
  139. optimizer = optim.Adam(classifier.parameters(), lr=args.learning_rate)
  140. # 定义学习率调度器，当验证损失不再降低时，降低学习率
  141. scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
  142.                                            mode='min', factor=0.5,
  143.                                            patience=1)
  144.  
  145. # 创建训练状态对象
  146. train_state = make_train_state(args)
  147. epoch_bar = tqdm_notebook(desc='training routine', 
  148.                           total=args.num_epochs,
  149.                           position=0)
  150.  
  151. dataset.set_split('train')
  152. train_bar = tqdm_notebook(desc='split=train',
  153.                           total=dataset.get_num_batches(args.batch_size), 
  154.                           position=1, 
  155.                           leave=True)
  156. dataset.set_split('val')
  157. val_bar = tqdm_notebook(desc='split=val',
  158.                         total=dataset.get_num_batches(args.batch_size), 
  159.                         position=1, 
  160.                         leave=True)
  161.  
  162. try:
  163.     for epoch_index in range(args.num_epochs):
  164.         train_state['epoch_index'] = epoch_index
  165.  
  166.         # Iterate over training dataset
  167.  
  168.         # setup: batch generator, set loss and acc to 0, set train mode on
  169.  
  170.         dataset.set_split('train')
  171.         batch_generator = generate_batches(dataset, 
  172.                                            batch_size=args.batch_size, 
  173.                                            device=args.device)
  174.         running_loss = 0.0
  175.         running_acc = 0.0
  176.         classifier.train()
  177.  
  178.         for batch_index, batch_dict in enumerate(batch_generator):
  179.             # the training routine is these 5 steps:
  180.  
  181.             # --------------------------------------
  182.             # step 1. zero the gradients
  183.             optimizer.zero_grad()
  184.  
  185.             # step 2. compute the output
  186.             y_pred = classifier(batch_dict['x_surname'])
  187.  
  188.             # step 3. compute the loss
  189.             loss = loss_func(y_pred, batch_dict['y_nationality'])
  190.             loss_t = loss.item()
  191.             running_loss += (loss_t - running_loss) / (batch_index + 1)
  192.  
  193.             # step 4. use loss to produce gradients
  194.             loss.backward()
  195.  
  196.             # step 5. use optimizer to take gradient step
  197.             optimizer.step()
  198.             # -----------------------------------------
  199.             # compute the accuracy
  200.             acc_t = compute_accuracy(y_pred, batch_dict['y_nationality'])
  201.             running_acc += (acc_t - running_acc) / (batch_index + 1)
  202.  
  203.             # update bar
  204.             train_bar.set_postfix(loss=running_loss, acc=running_acc, 
  205.                             epoch=epoch_index)
  206.             train_bar.update()
  207.  
  208.         train_state['train_loss'].append(running_loss)
  209.         train_state['train_acc'].append(running_acc)
  210.  
  211.         # Iterate over val dataset
  212.  
  213.         # setup: batch generator, set loss and acc to 0; set eval mode on
  214.         dataset.set_split('val')
  215.         batch_generator = generate_batches(dataset, 
  216.                                            batch_size=args.batch_size, 
  217.                                            device=args.device)
  218.         running_loss = 0.
  219.         running_acc = 0.
  220.         classifier.eval()
  221.  
  222.         for batch_index, batch_dict in enumerate(batch_generator):
  223.  
  224.             # compute the output
  225.             y_pred =  classifier(batch_dict['x_surname'])
  226.  
  227.             # step 3. compute the loss
  228.             loss = loss_func(y_pred, batch_dict['y_nationality'])
  229.             loss_t = loss.item()
  230.             running_loss += (loss_t - running_loss) / (batch_index + 1)
  231.  
  232.             # compute the accuracy
  233.             acc_t = compute_accuracy(y_pred, batch_dict['y_nationality'])
  234.             running_acc += (acc_t - running_acc) / (batch_index + 1)
  235.             val_bar.set_postfix(loss=running_loss, acc=running_acc, 
  236.                             epoch=epoch_index)
  237.             val_bar.update()
  238.  
  239.         train_state['val_loss'].append(running_loss)
  240.         train_state['val_acc'].append(running_acc)
  241.  
  242.         train_state = update_train_state(args=args, model=classifier,
  243.                                          train_state=train_state)
  244.  
  245.         scheduler.step(train_state['val_loss'][-1])
  246.  
  247.         if train_state['stop_early']:
  248.             break
  249.  
  250.         train_bar.n = 0
  251.         val_bar.n = 0
  252.         epoch_bar.update()
  253. except KeyboardInterrupt:
  254.     print("Exiting loop")

训练过程展示：

注意事项

  • 数据预处理：确保将姓氏数据转换为合适的格式，如字符序列，并进行适当的编码。
  • 模型结构：适当调整卷积层的参数（如卷积核大小、池化方式等），以适应数据的特征。
  • 训练和优化：根据模型在验证集上的表现调整超参数，如学习率、批量大小等。
声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号