我要评论多层感知机（mlp）简介
多层感知机是一种基础的神经网络架构，包括输入层、一个或多个隐藏层以及输出层。每个层都由神经元（单元）组成，执行加权输入的总和，然后通常使用relu（修正线性单元）等激活函数进行激活。
我们将使用pytorch实现一个基本的mlp。以下是定义mlp类的python代码示例：
import torch.nn as nn
import torch.nn.functional as f
import torch
class multilayerperceptron(nn.module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(multilayerperceptron, 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):
intermediate = f.relu(self.fc1(x_in))
output = self.fc2(intermediate)
if apply_softmax:
output = f.softmax(output, dim=1)
return output
代码解释
导入和设置: 我们导入必要的库（torch.nn用于神经网络组件，torch.nn.functional用于激活函数，torch用于张量操作）。
multilayerperceptron类:
__init__方法: 初始化mlp，输入参数包括input_dim、hidden_dim和output_dim。它定义了两个全连接层（nn.linear），其中fc1连接输入层和隐藏层，fc2连接隐藏层和输出层。
forward方法: 定义网络的前向传播。它对第一层（fc1）的输出应用relu激活，并通过第二层（fc2）计算最终输出。可选地，如果apply_softmax=true，则应用softmax激活（f.softmax）。
使用示例:
batch_size = 2
input_dim = 3
hidden_dim = 100
output_dim = 4
# 初始化模型
mlp = multilayerperceptron(input_dim, hidden_dim, output_dim)
# 生成随机输入张量
x_input = torch.rand(batch_size, input_dim)
# 不使用softmax的前向传播
y_output = mlp(x_input, apply_softmax=false)
print("不使用softmax的输出:")
print(y_output)
# 使用softmax的前向传播
y_output_softmax = mlp(x_input, apply_softmax=true)
print("\n使用softmax的输出:")
print(y_output_softmax)
我们使用pytorch构建多层感知机（mlp）的基础知识。我们讨论了mlp的架构，使用nn.module在pytorch中的实现，并展示了如何使用示例输入数据进行前向传播。pytorch提供了一个灵活高效的框架，适用于构建和训练各种深度学习模型，非常适合机器学习任务。
使用pytorch构建姓氏分类器
使用pytorch构建一个姓氏分类器。这个分类器将根据输入的姓氏预测其所属的国籍。我们将逐步介绍如何准备数据、构建模型以及进行训练和评估。
数据准备与向量化
首先，我们需要准备和向量化数据。我们将使用一个自定义的surnamedataset类来加载数据并进行向量化。以下是关键代码片段：
class surnamedataset(dataset):
def __init__(self, surname_df, vectorizer):
self.surname_df = surname_df
self.vectorizer = vectorizer
def __len__(self):
return len(self.surname_df)
def __getitem__(self, index):
row = self.surname_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}
class surnamevectorizer(object):
def __init__(self, surname_vocab, nationality_vocab):
self.surname_vocab = surname_vocab
self.nationality_vocab = nationality_vocab
def vectorize(self, surname):
one_hot = np.zeros(len(self.surname_vocab), dtype=np.float32)
for token in surname:
one_hot[self.surname_vocab.lookup_token(token)] = 1
return one_hot
@classmethod
def from_dataframe(cls, surname_df):
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)
模型构建
我们将使用一个简单的两层全连接神经网络（multilayer perceptron，mlp）作为我们的分类器。以下是我们的模型代码：
import torch.nn as nn
import torch.nn.functional as f
class surnameclassifier(nn.module):
def __init__(self, input_dim, hidden_dim, output_dim):
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):
intermediate_vector = f.relu(self.fc1(x_in))
prediction_vector = self.fc2(intermediate_vector)
if apply_softmax:
prediction_vector = f.softmax(prediction_vector, dim=1)
return prediction_vector
模型训练与评估
接下来，我们将展示如何训练和评估模型。我们使用pytorch的优化器（例如adam）和交叉熵损失函数来优化和计算损失。以下是训练步骤的核心代码：
import torch.optim as optim
# 初始化数据集和向量化器
dataset = surnamedataset.load_dataset_and_make_vectorizer(args.surname_csv)
vectorizer = dataset.get_vectorizer()
# 初始化分类器模型
classifier = surnameclassifier(input_dim=len(vectorizer.surname_vocab),
hidden_dim=args.hidden_dim,
output_dim=len(vectorizer.nationality_vocab))
classifier = classifier.to(args.device)
# 定义损失函数和优化器
loss_func = nn.crossentropyloss()
optimizer = optim.adam(classifier.parameters(), lr=args.learning_rate)
# 训练循环
for epoch in range(args.num_epochs):
classifier.train()
running_loss = 0.0
for batch_dict in dataset.generate_batches(batch_size=args.batch_size):
optimizer.zero_grad()
y_pred = classifier(batch_dict['x_surname'])
loss = loss_func(y_pred, batch_dict['y_nationality'])
loss.backward()
optimizer.step()
# 计算和记录损失
loss_batch = loss.to("cpu").item()
running_loss += (loss_batch - running_loss) / (batch_index + 1)
# 打印每个epoch的损失
print(f'epoch: {epoch+1}, training loss: {running_loss:.4f}')
# 保存模型状态
torch.save(classifier.state_dict(), args.model_state_file)
上面介绍了如何使用pytorch构建和训练一个简单的姓氏分类器。我们从数据预处理和向量化开始，到模型的构建、训练和保存，逐步展示了整个过程。
发表评论