pytorch入门（三）—— 前馈神经网络

前馈神经网络

常见的前馈神经网络有感知机（Perceptrons）、BP（Back Propagation）网络、RBF（Radial Basis Function）网络等。

感知器（又叫感知机）是最简单的前馈网络，它主要用于模式分类，也可用在基于模式分类的学习控制和多模态控制中。感知器网络可分为单层感知器网络和多层感知器网络。

BP网络是指连接权调整采用了反向传播学习算法的前馈网络。与感知器不同之处在于，BP网络的神经元变换函数采用了S形函数（Sigmoid函数），因此输出量是 0~1之间的连续量，可实现从输入到输出的任意的非线性映射。

RBF网络是指隐含层神经元由RBF神经元组成的前馈网络。RBF神经元是指神经元的变换函数为RBF（Radial Basis Function，径向基函数）的神经元。典型的RBF网络由三层组成：一个输入层，一个或多个由RBF神经元组成的RBF层（隐含层），一个由线性神经元组成的输出层。

代码实现

import torch as tr
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import torch.utils.data as Data
import matplotlib.pyplot as plt
from torch.autograd import Variable

input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

train_dataset = dsets.MNIST(root=./data,
        train=True,
        transform=transforms.ToTensor(),
        download=True)

test_dataset = dsets.MNIST(root=./data,
        train=False,
        transform=transforms.ToTensor())

train_loader = Data.DataLoader(dataset=train_dataset,
        batch_size=batch_size,
        shuffle=True)

test_loader = Data.DataLoader(dataset=test_dataset,
        batch_size=batch_size,
        shuffle=True)

class Net(nn.Module):
    """
    net 
    """
    def __init__(self, input_size, hideen_size, num_classes):
        """
        init
        """
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        """
        forward func
        """
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out


net = Net(input_size, hidden_size, num_classes)
print(net)

loss_func = nn.CrossEntropyLoss()

optimizer = tr.optim.Adam(net.parameters(), lr=learning_rate)


for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = Variable(images.view(-1, 28*28))
        labels = Variable(labels)
        optimizer.zero_grad()
        outputs = net(images)
        loss = loss_func(outputs, labels)
        loss.backward()
        optimizer.step()
        if (i+1) % 100 == 0:
            print(Epoch: [%d/%d], Step: [%d/%d], Loss: %.4f % (epoch+1, num_epochs, i+1,
                len(train_dataset)//batch_size, loss.item()))

correct = 0
total = 0
for images, labels in test_loader:
    images = Variable(images.view(-1, 28*28))
    outputs = net(images)
    _, predicted = tr.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print(Acdcuracy of the model on the 10000 test images: %d %% %
        (100 * correct / total))



for i in range(1,4):
    plt.imshow(train_dataset.train_data[i].numpy(), cmap=gray)
    plt.title(%i % train_dataset.train_labels[i])
    plt.show()

test_output = net(images[:20])
pred_y = tr.max(test_output, 1)[1].data.numpy().squeeze()
print(prediction number, pred_y)
print(real number, labels[:20].numpy())

tr.save(net.state_dict(), net.pkl)