MLP的每个神经元都包含一个激活函数，通常是非线性的，以使得网络可以学习非线性模式。常见的激活函数包括Sigmoid、Tanh等。MLP通过反向传播算法来训练，该算法使用梯度下降来调整网络中的权重，以最小化损失函数。通过反复迭代训练数据，MLP可以逐渐调整其参数，使其能够更好地拟合训练数据，并在未见过的数据上进行泛化。

MLP是一种灵活且强大的模型，可以应用于各种问题领域，如图像识别、自然语言处理、推荐系统等。

1.2 激活函数

1.2.1 激活函数性质

激活函数需要具备以下几点性质:

        1. 连续并可导（允许少数点上不可导）的非线性函数。可导的激活函数可以直接利用数值优化的方法来学习网络参数。
        2. 激活函数及其导函数要尽可能的简单，有利于提高网络计算效率。
        3. 激活函数的导函数的值域要在一个合适的区间内，不能太大也不能太小，否则会影响训练的效率和稳定性。

1.2.2 sigmoid函数

sigmoid 是神经网络历史上最早使用的激活函数之一。它取任何实值并将其压缩在0和1之间。数学上，sigmoid 的表达式如下：

$y=\frac{1}{1+e^{-x}}$

从结果中很容易看出，sigmoid 是一个光滑的、可微的函数。

1.2.3 tanh函数

tanh 激活函数是 sigmoid 在外观上的不同变体，输出范围在(-1, 1)之间，输出值为零中心，这意味着数据的平均值更接近于零，有助于加快收敛速度，tanh的表达式如下：

$y=\frac{e^{x}-e^{-x}}{e^{x}+e^{-x}}$

tanh在特征相差明显时的效果会很好，在循环过程中会不断扩大特征效果。与sigmod的区别是 tanh 是0 的均值，因此在实际应用中tanh会比sigmod更好。

在具体应用中，tanh函数相比于Sigmoid函数往往更具有优越性，这主要是因为Sigmoid函数在输入处于[-1,1]之间时，函数值变化敏感，一旦接近或者超出区间就失去敏感性，处于饱和状态。

1.3 前向传播

MLP的前向传播过程即从输入层到输出层的计算过程。它涉及到权重和偏置的计算、激活函数的应用等。具体步骤如下：

假设网络有 $L$ 层，其中第 $l$ 层的输入 $a^{(l-1)}$ 为，权重矩阵为 $W^{(l)}$ ，偏置向量为 $b^{(l)}$ ，激活函数为 $f$ ，则第 $l$ 层的输出 $a^{(l)}$ 计算如下：

$z^{(l)}=W^{(l)}a^{(l-1)}+b^{(l)}$

$a^{(l)}=f(z^{(l)})$

1.4 反向传播

反向传播算法是用于训练MLP模型的关键步骤。通过计算梯度来调整权重和偏置，以最小化预测结果与真实结果之间的误差。具体步骤如下：

损失计算：首先计算网络的输出与真实标签之间的损失。常用的损失函数包括均方误差（MSE）和交叉熵（Cross-Entropy）。
计算输出层的梯度：
- 损失函数对输出层的输入 $z^{(l)}$ 的梯度：

$\delta ^{(l)}=\frac{\partial L}{\partial z^{(l)}}$

计算隐藏层的梯度：
- 损失函数对第 $l$ 层输入的梯度 $z^{(l)}$ ：

$\delta ^{l}=(W^{(l+1)})^{T}\delta ^{(l+1)}\circ f'(z^{(l)})$

其中， $\circ$ 表示元素乘积（Hadamard乘积）， $f'(z^{(l)})$ 是激活函数的导数。

计算梯度：
- 对于权重 $W^{(l)}$ 和偏置 $b^{(l)}$ 的梯度：

$\frac{\partial L}{\partial W^{(l)}}=\delta ^{(l)}(a^{(l-1)})^{T}$

$\frac{\partial L}{\partial b^{(l)}}=\delta ^{(l)}$

更新权重和偏置：
- 使用梯度下降法更新参数：

$W^{(l)}=W^{(l)}-\eta \frac{\partial L}{\partial W^{(l)}}$

$b^{(l)}=b^{(l)}-\eta \frac{\partial L}{\partial b^{(l)}}$

其中， $\eta$ 是学习率。

1.5 MLP实现姓氏分类

1.5.1 数据集（The SurnameDataset）

姓氏数据集，它收集了来自18个不同国家的10,000个姓氏，这些姓氏是作者从互联网上不同的姓名来源收集的。该数据集将在本实验的几个示例中重用，并具有一些使其有趣的属性。第一个性质是它是相当不平衡的。排名前三的课程占数据的60%以上:27%是英语，21%是俄语，14%是阿拉伯语。剩下的15个民族的频率也在下降——这也是语言特有的特性。第二个特点是，在国籍和姓氏正字法(拼写)之间有一种有效和直观的关系。有些拼写变体与原籍国联系非常紧密(比如“O ‘Neill”、“Antonopoulos”、“Nagasawa”或“Zhu”)。

为了创建最终的数据集，从一个比课程补充材料中包含的版本处理更少的版本开始，并执行了几个数据集修改操作。第一个目的是减少这种不平衡——原始数据集中70%以上是俄文，这可能是由于抽样偏差或俄文姓氏的增多。为此，我们通过选择标记为俄语的姓氏的随机子集对这个过度代表的类进行子样本。接下来，我们根据国籍对数据集进行分组，并将数据集分为三个部分:70%到训练数据集，15%到验证数据集，最后15%到测试数据集，以便跨这些部分的类标签分布具有可比性。

代码如下：


class SurnameDataset(Dataset):
    def __init__(self, surname_df, vectorizer):
        """
        参数:
            surname_df (pandas.DataFrame): 数据集
            vectorizer (SurnameVectorizer): 从数据集实例化的向量化器
        """
        self.surname_df = surname_df
        self._vectorizer = vectorizer
 
        # 拆分数据集为训练集、验证集和测试集
        self.train_df = self.surname_df[self.surname_df.split=='train']
        self.train_size = len(self.train_df)
 
        self.val_df = self.surname_df[self.surname_df.split=='val']
        self.validation_size = len(self.val_df)
 
        self.test_df = self.surname_df[self.surname_df.split=='test']
        self.test_size = len(self.test_df)
 
        self._lookup_dict = {'train': (self.train_df, self.train_size),
                             'val': (self.val_df, self.validation_size),
                             'test': (self.test_df, self.test_size)}
 
        self.set_split('train')
        
        # 类别权重
        class_counts = surname_df.nationality.value_counts().to_dict()
        def sort_key(item):
            return self._vectorizer.nationality_vocab.lookup_token(item[0])
        sorted_counts = sorted(class_counts.items(), key=sort_key)
        frequencies = [count for _, count in sorted_counts]
        self.class_weights = 1.0 / torch.tensor(frequencies, dtype=torch.float32)
 
    @classmethod
    def load_dataset_and_make_vectorizer(cls, surname_csv):
        """加载数据集并从头创建一个新的向量化器
        
        参数:
            surname_csv (str): 数据集的位置
        返回:
            SurnameDataset的一个实例
        """
        surname_df = pd.read_csv(surname_csv)
        train_surname_df = surname_df[surname_df.split=='train']
        return cls(surname_df, SurnameVectorizer.from_dataframe(train_surname_df))
 
    @classmethod
    def load_dataset_and_load_vectorizer(cls, surname_csv, vectorizer_filepath):
        """加载数据集和相应的向量化器。用于向量化器已被缓存以供重用的情况
        
        参数:
            surname_csv (str): 数据集的位置
            vectorizer_filepath (str): 已保存的向量化器的位置
        返回:
            SurnameDataset的一个实例
        """
        surname_df = pd.read_csv(surname_csv)
        vectorizer = cls.load_vectorizer_only(vectorizer_filepath)
        return cls(surname_df, vectorizer)
 
    @staticmethod
    def load_vectorizer_only(vectorizer_filepath):
        """从文件加载向量化器的静态方法
        
        参数:
            vectorizer_filepath (str): 序列化向量化器的位置
        返回:
            SurnameVectorizer的一个实例
        """
        with open(vectorizer_filepath) as fp:
            return SurnameVectorizer.from_serializable(json.load(fp))
 
    def save_vectorizer(self, vectorizer_filepath):
        """使用json将向量化器保存到磁盘
        
        参数:
            vectorizer_filepath (str): 保存向量化器的位置
        """
        with open(vectorizer_filepath, "w") as fp:
            json.dump(self._vectorizer.to_serializable(), fp)
 
    def get_vectorizer(self):
        """ 返回向量化器 """
        return self._vectorizer
 
    def set_split(self, split="train"):
        """ 使用数据框中的列选择数据集的拆分 """
        self._target_split = split
        self._target_df, self._target_size = self._lookup_dict[split]
 
    def __len__(self):
        return self._target_size
 
    def __getitem__(self, index):
        """PyTorch数据集的主要入口点方法
        
        参数:
            index (int): 数据点的索引
        返回:
            一个包含数据点的字典:
                特征 (x_surname)
                标签 (y_nationality)
        """
        row = self._target_df.iloc[index]
 
        surname_vector = self._vectorizer.vectorize(row.surname)
 
        nationality_index = self._vectorizer.nationality_vocab.lookup_token(row.nationality)
 
        return {'x_surname': surname_vector,
                'y_nationality': nationality_index}
 
    def get_num_batches(self, batch_size):
        """给定批量大小，返回数据集中的批次数量
        
        参数:
            batch_size (int)
        返回:
            数据集中的批次数量
        """
        return len(self) // batch_size
 
    
def generate_batches(dataset, batch_size, shuffle=True,
                     drop_last=True, device="cpu"): 
    """
    一个包装PyTorch DataLoader的生成器函数。它将确保每个张量在正确的设备位置上。
    """
    dataloader = DataLoader(dataset=dataset, batch_size=batch_size,
                            shuffle=shuffle, drop_last=drop_last)
 
    for data_dict in dataloader:
        out_data_dict = {}
        for name, tensor in data_dict.items():
            out_data_dict[name] = data_dict[name].to(device)
        yield out_data_dict

1.5.2 词汇表、向量化器（Vocabulary, Vectorizer, and DataLoader）


class Vocabulary(object):
    """用于处理文本并提取词汇以进行映射的类"""
 
    def __init__(self, token_to_idx=None, add_unk=True, unk_token="<UNK>"):
        """
        初始化Vocabulary实例。
        参数:
            token_to_idx (dict): 一个现有的将标记映射到索引的字典
            add_unk (bool): 一个指示是否添加UNK标记的标志
            unk_token (str): 要添加到词汇表中的UNK标记
        """
 
        if token_to_idx is None:
            token_to_idx = {}
        self._token_to_idx = token_to_idx
 
        # 创建从索引到标记的反向映射
        self._idx_to_token = {idx: token for token, idx in self._token_to_idx.items()}
        
        self._add_unk = add_unk
        self._unk_token = unk_token
        
        self.unk_index = -1
        # 如果要求，将UNK标记添加到词汇表中
        if add_unk:
            self.unk_index = self.add_token(unk_token) 
        
    def to_serializable(self):
        """返回一个可序列化的字典。"""
        return {'token_to_idx': self._token_to_idx, 
                'add_unk': self._add_unk, 
                'unk_token': self._unk_token}
 
    @classmethod
    def from_serializable(cls, contents):
        """从序列化字典实例化Vocabulary。"""
        return cls(**contents)
 
    def add_token(self, token):
        """基于标记更新映射字典。
        参数:
            token (str): 要添加到Vocabulary中的项
        返回:
            index (int): 对应于标记的整数
        """
        try:
            index = self._token_to_idx[token]
        except KeyError:
            index = len(self._token_to_idx)
            self._token_to_idx[token] = index
            self._idx_to_token[index] = token
        return index
    
    def add_many(self, tokens):
        """将标记列表添加到Vocabulary中。
        
        参数:
            tokens (list): 字符串标记列表
        返回:
            indices (list): 与标记对应的索引列表
        """
        return [self.add_token(token) for token in tokens]
 
    def lookup_token(self, token):
        """检索与标记相关联的索引，如果标记不存在，则使用UNK索引。
        
        参数:
            token (str): 要查找的标记
        返回:
            index (int): 与标记相关的索引
        注意:
            UNK功能需要unk_index >= 0（已添加到Vocabulary中）
        """
        if self.unk_index >= 0:
            return self._token_to_idx.get(token, self.unk_index)
        else:
            return self._token_to_idx[token]
 
    def lookup_index(self, index):
        """返回与索引相关联的标记。
        
        参数: 
            index (int): 要查找的索引
        返回:
            token (str): 与索引相关的标记
        引发:
            KeyError: 如果索引不在Vocabulary中
        """
        if index not in self._idx_to_token:
            raise KeyError("索引(%d)不在Vocabulary中" % index)
        return self._idx_to_token[index]
 
    def __str__(self):
        """返回Vocabulary的字符串表示形式。"""
        return "<Vocabulary(size=%d)>" % len(self)
 
    def __len__(self):
        """返回Vocabulary中唯一标记的数量。"""
        return len(self._token_to_idx)


class SurnameVectorizer(object):
    """协调Vocabularies并将它们应用于实际用途的向量化器"""
 
    def __init__(self, surname_vocab, nationality_vocab):
        """
        参数:
            surname_vocab (Vocabulary): 将字符映射到整数的词汇表
            nationality_vocab (Vocabulary): 将国籍映射到整数的词汇表
        """
        self.surname_vocab = surname_vocab
        self.nationality_vocab = nationality_vocab
 
    def vectorize(self, surname):
        """
        将姓氏向量化为一种折叠的one-hot编码。
        参数:
            surname (str): 姓氏
        返回:
            one_hot (np.ndarray): 一个折叠的one-hot编码
        """
        vocab = self.surname_vocab
        one_hot = np.zeros(len(vocab), dtype=np.float32)
        for token in surname:
            one_hot[vocab.lookup_token(token)] = 1
 
        return one_hot
 
    @classmethod
    def from_dataframe(cls, surname_df):
        """从数据集DataFrame实例化向量化器。
        参数:
            surname_df (pandas.DataFrame): 姓氏数据集
        返回:
            SurnameVectorizer的实例
        """
        surname_vocab = Vocabulary(unk_token="@")
        nationality_vocab = Vocabulary(add_unk=False)
 
        for index, row in surname_df.iterrows():
            for letter in row.surname:
                surname_vocab.add_token(letter)
            nationality_vocab.add_token(row.nationality)
 
        return cls(surname_vocab, nationality_vocab)
 
    @classmethod
    def from_serializable(cls, contents):
        surname_vocab = Vocabulary.from_serializable(contents['surname_vocab'])
        nationality_vocab = Vocabulary.from_serializable(contents['nationality_vocab'])
        return cls(surname_vocab=surname_vocab, nationality_vocab=nationality_vocab)
 
    def to_serializable(self):
        """返回一个可序列化的字典。"""
        return {'surname_vocab': self.surname_vocab.to_serializable(),
                'nationality_vocab': self.nationality_vocab.to_serializable()}

1.5.3 分类模型（The Surname Classifier Model）

第一个线性层将输入向量映射到中间向量，并对该向量应用非线性。第二线性层将中间向量映射到预测向量。在最后一步中，可选地应用softmax操作，以确保输出和为1;这就是所谓的“概率”。它是可选的原因与我们使用的损失函数的数学公式有关——交叉熵损失。我们研究了“损失函数”中的交叉熵损失。回想一下，交叉熵损失对于多类分类是最理想的，但是在训练过程中软最大值的计算不仅浪费而且在很多情况下并不稳定。

代码如下：


import torch.nn as nn
import torch.nn.functional as F
 
class SurnameClassifier(nn.Module):
    """用于姓氏分类的两层多层感知器"""
    def __init__(self, input_dim, hidden_dim, output_dim):
        """
        参数:
            input_dim (int): 输入向量的大小
            hidden_dim (int): 第一个线性层的输出大小
            output_dim (int): 第二个线性层的输出大小
        """
        super(SurnameClassifier, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)  # 第一个线性层
        self.fc2 = nn.Linear(hidden_dim, output_dim)  # 第二个线性层
 
    def forward(self, x_in, apply_softmax=False):
        """分类器的前向传播
        
        参数:
            x_in (torch.Tensor): 输入数据张量。x_in的形状应为 (batch, input_dim)
            apply_softmax (bool): 是否应用softmax激活的标志
                如果与交叉熵损失一起使用，应设置为False
        返回:
            结果张量。张量的形状应为 (batch, output_dim)
        """
        intermediate_vector = F.relu(self.fc1(x_in))  # 通过第一个线性层并应用ReLU激活函数
        prediction_vector = self.fc2(intermediate_vector)  # 通过第二个线性层
 
        if apply_softmax:
            prediction_vector = F.softmax(prediction_vector, dim=1)  # 如果需要，应用softmax激活函数
 
        return prediction_vector

1.5.4 训练（The Training Routine）

虽然我们使用了不同的模型、数据集和损失函数，但是训练例程是相同的。

部分代码如下：


# 设置参数
args = Namespace(
    # 数据和路径信息
    surname_csv="data/surnames/surnames_with_splits.csv",
    vectorizer_file="vectorizer.json",
    model_state_file="model.pth",
    save_dir="model_storage/ch4/surname_mlp",
    # 模型超参数
    hidden_dim=300,
    # 训练超参数
    seed=1337,
    num_epochs=100,
    early_stopping_criteria=5,
    learning_rate=0.001,
    batch_size=64,
    # 运行时选项
    cuda=False,
    reload_from_files=False,
    expand_filepaths_to_save_dir=True,
)
 
# 扩展文件路径
if args.expand_filepaths_to_save_dir:
    args.vectorizer_file = os.path.join(args.save_dir, args.vectorizer_file)
    args.model_state_file = os.path.join(args.save_dir, args.model_state_file)
    
    print("扩展的文件路径: ")
    print("\t{}".format(args.vectorizer_file))
    print("\t{}".format(args.model_state_file))
    
# 检查 CUDA 可用性
if not torch.cuda.is_available():
    args.cuda = False
 
args.device = torch.device("cuda" if args.cuda else "cpu")
print("使用 CUDA: {}".format(args.cuda))
 
# 设置随机种子以保证可重复性
def set_seed_everywhere(seed, cuda):
    torch.manual_seed(seed)
    if cuda:
        torch.cuda.manual_seed_all(seed)
 
set_seed_everywhere(args.seed, args.cuda)
 
# 处理目录
def handle_dirs(dirpath):
    if not os.path.exists(dirpath):
        os.makedirs(dirpath)
 
handle_dirs(args.save_dir)

训练中最显著的差异与模型中输出的种类和使用的损失函数有关。在这个例子中，输出是一个多类预测向量，可以转换为概率。正如在模型描述中所描述的，这种输出的损失类型仅限于CrossEntropyLoss和NLLLoss。由于它的简化，我们使用了CrossEntropyLoss。

THE TRAINING LOOP

示例显示了使用不同的key从batch_dict中获取数据。除了外观上的差异，训练循环的功能保持不变。利用训练数据，计算模型输出、损失和梯度。然后，使用梯度来更新模型。


scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
                                                 mode='min', factor=0.5,
                                                 patience=1)
# 初始化训练状态
train_state = make_train_state(args)
 
epoch_bar = tqdm(desc='training routine',   # 迭代轮次
                 total=args.num_epochs,
                 position=0)
 
dataset.set_split('train')
train_bar = tqdm(desc='split=train',
                 total=dataset.get_num_batches(args.batch_size), 
                 position=1, 
                 leave=True)
dataset.set_split('val')
val_bar = tqdm(desc='split=val',
               total=dataset.get_num_batches(args.batch_size), 
               position=1, 
               leave=True)
 
try:
    for epoch_index in range(args.num_epochs):
        train_state['epoch_index'] = epoch_index
 
        # Iterate over training dataset
 
      
        #  设置: 批处理生成器, 将损失和准确率设为0, 设置训练模式
        dataset.set_split('train')
        batch_generator = generate_batches(dataset, 
                                           batch_size=args.batch_size, 
                                           device=args.device)
        running_loss = 0.0
        running_acc = 0.0
        classifier.train()
 
        for batch_index, batch_dict in enumerate(batch_generator):
            # the training routine is these 5 steps:
 
            # --------------------------------------
            # 步骤 1. 清零梯度
            optimizer.zero_grad()
 
            # 计算输出
            y_pred = classifier(batch_dict['x_surname'])
 
            #  计算损失
            loss = loss_func(y_pred, batch_dict['y_nationality'])
            loss_t = loss.item()
            running_loss += (loss_t - running_loss) / (batch_index + 1)
 
          # 计算准确率
            loss.backward()
 
            # step 5. use optimizer to take gradient step
            optimizer.step()
            # -----------------------------------------
            # compute the accuracy
            acc_t = compute_accuracy(y_pred, batch_dict['y_nationality'])
            running_acc += (acc_t - running_acc) / (batch_index + 1)
 
            # update bar
            train_bar.set_postfix(loss=running_loss, acc=running_acc, 
                            epoch=epoch_index)
            train_bar.update()
 
        train_state['train_loss'].append(running_loss)
        train_state['train_acc'].append(running_acc)
 
        # Iterate over val dataset
 
        # setup: batch generator, set loss and acc to 0; set eval mode on
        dataset.set_split('val')
        batch_generator = generate_batches(dataset, 
                                           batch_size=args.batch_size, 
                                           device=args.device)
        running_loss = 0.
        running_acc = 0.
        classifier.eval()
 
        for batch_index, batch_dict in enumerate(batch_generator):
 
            # 计算输出
            y_pred =  classifier(batch_dict['x_surname'])
 
            #  计算损失
            loss = loss_func(y_pred, batch_dict['y_nationality'])
            loss_t = loss.to("cpu").item()
            running_loss += (loss_t - running_loss) / (batch_index + 1)
 
             # 计算准确率
            acc_t = compute_accuracy(y_pred, batch_dict['y_nationality'])
            running_acc += (acc_t - running_acc) / (batch_index + 1)
            val_bar.set_postfix(loss=running_loss, acc=running_acc, 
                            epoch=epoch_index)
            val_bar.update()
 
        train_state['val_loss'].append(running_loss)
        train_state['val_acc'].append(running_acc)
        
          # 更新训练状态并根据验证损失调整学习率
        train_state = update_train_state(args=args, model=classifier,
                                         train_state=train_state)
 
        scheduler.step(train_state['val_loss'][-1])
 
        if train_state['stop_early']:
            break
 
        train_bar.n = 0
        val_bar.n = 0
        epoch_bar.update()
except KeyboardInterrupt:
    print("Exiting loop")

1.5.5 评估（Evaluation）

为了要了解模型的性能，需要对性能进行定量和定性的度量，现在通过以下代码，打印损失和准确率。


# 加载最佳模型
classifier.load_state_dict(torch.load(train_state['model_filename']))
 
# 将模型和数据集转移到GPU或CPU
classifier = classifier.to(args.device)
dataset.class_weights = dataset.class_weights.to(args.device)
 
# 定义损失函数
loss_func = nn.CrossEntropyLoss(dataset.class_weights)
 
# 设置数据集为测试集并迭代批次计算损失和准确率
dataset.set_split('test')
batch_generator = generate_batches(dataset, 
                                   batch_size=args.batch_size, 
                                   device=args.device)
running_loss = 0.
running_acc = 0.
classifier.eval()
 
for batch_index, batch_dict in enumerate(batch_generator):
    # 计算输出
    y_pred =  classifier(batch_dict['x_surname'])
    
    # 计算损失
    loss = loss_func(y_pred, batch_dict['y_nationality'])
    loss_t = loss.item()
    running_loss += (loss_t - running_loss) / (batch_index + 1)
 
    # 计算准确率
    acc_t = compute_accuracy(y_pred, batch_dict['y_nationality'])
    running_acc += (acc_t - running_acc) / (batch_index + 1)
 
# 更新训练状态的测试损失和准确率
train_state['test_loss'] = running_loss
train_state['test_acc'] = running_acc
 
# 打印测试损失和准确率
print("Test loss: {};".format(train_state['test_loss']))  
print("Test Accuracy: {}".format(train_state['test_acc']))

结果如下：

由结果可知，MLP的准确率为46.69%。

1.5.6 预测（Predict）

代码如下：


def predict_nationality(surname, classifier, vectorizer):
    """预测姓氏的国籍
    
    Args:
        surname (str): 要分类的姓氏
        classifier (SurnameClassifer): 分类器的实例
        vectorizer (SurnameVectorizer): 对应的向量化器
    Returns:
        包含最可能的国籍及其概率的字典
    """
    # 将姓氏向量化
    vectorized_surname = vectorizer.vectorize(surname)
    vectorized_surname = torch.tensor(vectorized_surname).view(1, -1)
    
    # 使用分类器进行预测，并应用softmax函数
    result = classifier(vectorized_surname, apply_softmax=True)
 
    # 获取概率值和索引
    probability_values, indices = result.max(dim=1)
    index = indices.item()
 
    # 查找国籍
    predicted_nationality = vectorizer.nationality_vocab.lookup_index(index)
    probability_value = probability_values.item()
 
    return {'nationality': predicted_nationality, 'probability': probability_value}
 
# 输入要分类的姓氏
new_surname = input("Enter a surname to classify: ")
 
# 将分类器移到CPU上
classifier = classifier.to("cpu")
 
# 使用预测函数进行预测
prediction = predict_nationality(new_surname, classifier, vectorizer)
 
# 打印结果
print("{} -> {} (p={:0.2f})".format(new_surname,
                                    prediction['nationality'],
                                    prediction['probability']))

预测结果如下：

作者小王输入自己的姓氏“王”，由结果可知，预测出最可能的国籍是韩国，预测大概出错了（声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】