实现多层感知机

Ctrl+CV九段手

已于 2024-07-12 21:53:10 修改

阅读量747

点赞数 22

分类专栏：机器学习和深度学习文章标签：机器学习人工智能深度学习 pytorch 神经网络语言模型学习方法

于 2024-07-12 15:32:42 首次发布

本文链接：https://blog.csdn.net/2302_80644606/article/details/140374840

版权

机器学习和深度学习专栏收录该内容

22 篇文章 0 订阅

订阅专栏

多层感知机：

介绍：

缩写：MLP，这是一种人工神经网络，由一个输入层、一个或多个隐藏层以及一个输出层组成，每一层都由多个节点（神经元）构成。在MLP中，节点之间只有前向连接，没有循环连接，这使得它属于前馈神经网络的一种。每个节点都应用一个激活函数，如sigmoid、ReLU等，以引入非线性，从而使网络能够拟合复杂的函数和数据分布。

代码实现：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# Step 1: Define the MLP model
class SimpleMLP(nn.Module):
    def __init__(self):
        super(SimpleMLP, self).__init__()
        self.fc1 = nn.Linear(784, 128)  # Input layer to hidden layer
        self.fc2 = nn.Linear(128, 64)   # Hidden layer to another hidden layer
        self.fc3 = nn.Linear(64, 10)    # Hidden layer to output layer
        self.relu = nn.ReLU()

    def forward(self, x):
        x = x.view(-1, 784)             # Flatten the input from 28x28 to 784
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Step 2: Load MNIST dataset
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# Step 3: Define loss function and optimizer
model = SimpleMLP()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Step 4: Train the model
num_epochs = 5
for epoch in range(num_epochs):
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))

# Step 5: Evaluate the model on the test set (optional)
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the network on the 10000 test images: {} %'.format(100 * correct / total))

运行结果：

问题答疑：

线性变换与非线性变换

在神经网络中

线性变换通常指的是权重矩阵和输入数据的矩阵乘法，再加上偏置向量。数学上，对于一个输入向量𝑥x和权重矩阵𝑊W，加上偏置向量𝑏b，线性变换可以表示为： 𝑧=𝑊𝑥+𝑏z=Wx+b

非线性变换是指在神经网络的每一层之后应用的激活函数，如ReLU、sigmoid或tanh等。这些函数引入了非线性，使神经网络能够学习和表达复杂的函数关系。没有非线性变换，无论多少层的神经网络最终都将简化为一个线性模型。

参数含义

在上述模型中，参数如784, 128, 64, 10并不是字节，而是神经网络层的尺寸，具体来说是神经元的数量：

784: 这是输入层的神经元数量，对应于MNIST数据集中每个图片的像素数量。MNIST的图片是28x28像素，因此总共有784个像素点。
128 和 64: 这是两个隐藏层的神经元数量。它们代表了第一层和第二层的宽度，即这一层有多少个神经元。
10: 这是输出层的神经元数量，对应于MNIST数据集中的10个数字类别（0到9）。