如何利用PyTorch API构建CNN?

　　很多人对于卷积神经网络(CNN)并不了解，卷积神经网络是一种前馈神经网络，它包括卷积计算并具有很深的结构，卷积神经网络是深度学习的代表性算法之一。那么如何利用PyTorch API构建CNN?方式有哪些?今天本文将以一个简单的指南，将帮助您构建和了解构建简单的CNN的概念。通过阅读本文之后，将能够基于PyTorch API构建一个简单的CNN，并使用FashionMNIST日期集对服装进行分类。但前提是您已具备人工神经网络知识。
　　如何利用PyTorch API构建CNN?
　　CNN或卷积神经网络的工作原理与人眼的工作原理非常相似。CNN背后的核心运算是矩阵加法和乘法，因此无需担心它们。
　　但是要了解CNN的工作原理，我们需要了解如何将图像存储在计算机中。
　　上面的向我们展示了如何以数组形式存储图像。
　　但是，这些只是灰度图像。因此，RGB或彩色图像是3个这样的矩阵彼此堆叠的。
　　CNN架构
　　CNN的核心功能是卷积运算。将图像矩阵与滤波器矩阵相乘以从图像矩阵中提取一些重要特征。
　　上述显示了对图像矩阵的卷积运算。通过使滤波器矩阵移动通过图像矩阵来填充卷积矩阵。
　　CNN的另一个重要组成部分称为最大池层。这有助于我们减少功能部件的数量，即使功能锐化以使我们的CNN性能更好。
　　对于所有卷积层，我们都应用RELU激活函数。
　　在将卷积层映射到输出时，我们需要使用线性层。因此，我们使用称为全连接层(简称为fc)的层。最终fc的激活大部分是S型激活函数。
　　我们可以清楚地看到所有输入值在0和1之间的输出映射。
　　现在，您已经知道我们将要使用的图层。这些知识足以构建一个简单的CNN，但是一个可选的调用dropout的层将有助于CNN发挥良好的作用。辍学层位于fc层之间，这会以设定的概率随机丢弃连接，这将有助于我们更好地训练CNN。
　　我们的CNN体系结构，但最后，我们将在fc层之间添加一个dropout。
　　不再浪费时间，我们将开始编写代码。
　　import torchimport torchvision# data loading and transformingfrom torchvision.datasets import FashionMNISTfrom torch.utils.data import DataLoaderfrom torchvision import transforms# The output of torchvision datasets are PILImage images of range [0, 1]. # We transform them to Tensors for input into a CNN## Define a transform to read the data in as a tensor
　　data_transform = transforms.ToTensor()# choose the training and test datasets
　　train_data = FashionMNIST(root='./data', train=True,
　　download=True, transform=data_transform)
　　test_data = FashionMNIST(root='./data', train=False,
　　download=True, transform=data_transform)# Print out some stats about the training and test data
　　print('Train data, number of images: ', len(train_data))
　　print('Test data, number of images: ', len(test_data))# prepare data loaders, set the batch_size
　　batch_size = 20
　　train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
　　test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=True)# specify the image classes
　　classes = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
　　'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
　　For visualizing the Data import numpy as npimport matplotlib.pyplot as plt
　　%matplotlib inline
　　# obtain one batch of training images
　　dataiter = iter(train_loader)
　　images, labels = dataiter.next()
　　images = images.numpy()# plot the images in the batch, along with the corresponding labels
　　fig = plt.figure(figsize=(25, 4))for idx in np.arange(batch_size):
　　ax = fig.add_subplot(2, batch_size/2, idx+1, xticks=[], yticks=[])
　　ax.imshow(np.squeeze(images[idx]), cmap='gray')
　　ax.set_title(classes[labels[idx]])# Defining the CNNimport torch.nn as nnimport torch.nn.functional as Fclass Net(nn.Module):
　　def __init__(self):
　　super(Net, self).__init__()
　　# 1 input image channel (grayscale), 10 output channels/feature maps
　　# 3x3 square convolution kernel
　　## output size = (W-F)/S +1 = (28-3)/1 +1 = 26
　　# the output Tensor for one image, will have the dimensions: (10, 26, 26)
　　# after one pool layer, this becomes (10, 13, 13)
　　self.conv1 = nn.Conv2d(1, 10, 3)
　　# maxpool layer
　　# pool with kernel_size=2, stride=2
　　self.pool = nn.MaxPool2d(2, 2)
　　# second conv layer: 10 inputs, 20 outputs, 3x3 conv
　　## output size = (W-F)/S +1 = (13-3)/1 +1 = 11
　　# the output tensor will have dimensions: (20, 11, 11)
　　# after another pool layer this becomes (20, 5, 5); 5.5 is rounded down
　　self.conv2 = nn.Conv2d(10, 20, 3)
　　# 20 outputs * the 5*5 filtered/pooled map size
　　self.fc1 = nn.Linear(20*5*5, 50)
　　# dropout with p=0.4
　　self.fc1_drop = nn.Dropout(p=0.4)
　　# finally, create 10 output channels (for the 10 classes)
　　self.fc2 = nn.Linear(50, 10)
　　# define the feedforward behavior
　　def forward(self, x):
　　# two conv/relu + pool layers
　　x = self.pool(F.relu(self.conv1(x)))
　　x = self.pool(F.relu(self.conv2(x)))
　　# prep for linear layer
　　# this line of code is the equivalent of Flatten in Keras
　　x = x.view(x.size(0), -1)
　　# two linear layers with dropout in between
　　x = F.relu(self.fc1(x))
　　x = self.fc1_drop(x)
　　x = self.fc2(x)
　　# final output
　　return x# instantiate and print your Net
　　net = Net()
　　print(net)import torch.optim as optim# using cross entropy whcih combines softmax and NLL loss
　　criterion = nn.CrossEntropyLoss()# stochastic gradient descent with a small learning rate and some momentum
　　optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)# Training the CNNdef train(n_epochs):
　　loss_over_time = [] # to track the loss as the network trains
　　for epoch in range(n_epochs): # loop over the dataset multiple times
　　running_loss = 0.0
　　for batch_i, data in enumerate(train_loader):
　　# get the input images and their corresponding labels
　　inputs, labels = data
　　# zero the parameter (weight) gradients
　　optimizer.zero_grad()
　　# forward pass to get outputs
　　outputs = net(inputs)
　　# calculate the loss
　　loss = criterion(outputs, labels)
　　# backward pass to calculate the parameter gradients
　　loss.backward()
　　# update the parameters
　　optimizer.step()
　　# print loss statistics
　　# to convert loss into a scalar and add it to running_loss, we use .item()
　　running_loss += loss.item()
　　if batch_i % 1000 == 999: # print every 1000 batches
　　avg_loss = running_loss/1000
　　# record and print the avg loss over the 1000 batches
　　loss_over_time.append(avg_loss)
　　print('Epoch: {}, Batch: {}, Avg. Loss: {}'.format(epoch + 1, batch_i+1, avg_loss))
　　running_loss = 0.0
　　print('Finished Training')
　　return loss_over_time# define the number of epochs to train for
　　n_epochs = 30 # start small to see if your model works, initially# call train
　　training_loss = train(n_epochs)# visualize the loss as the network trained
　　plt.plot(training_loss)
　　plt.xlabel('1000's of batches')
　　plt.ylabel('loss')
　　plt.ylim(0, 2.5) # consistent scale
　　plt.show()# obtain one batch of test images
　　dataiter = iter(test_loader)
　　images, labels = dataiter.next()# get predictions
　　preds = np.squeeze(net(images).data.max(1, keepdim=True)[1].numpy())
　　images = images.numpy()# plot the images in the batch, along with predicted and true labels
　　fig = plt.figure(figsize=(25, 4))for idx in np.arange(batch_size):
　　ax = fig.add_subplot(2, batch_size/2, idx+1, xticks=[], yticks=[])
　　ax.imshow(np.squeeze(images[idx]), cmap='gray')
　　ax.set_title("{} ({})".format(classes[preds[idx]], classes[labels[idx]]),
　　color=("green" if preds[idx]==labels[idx] else "red"))
　　以上就是关于如何利用PyTorch API构建CNN的全部内容介绍，想了解更多关于卷积神经网络的信息，请继续关注中培教育。原文链接：http://www.zpedu.com/it/jxwz/11617.html