深度学习课程笔记（一）CNN 卷积神经网络

深度学习课程笔记（一）CNN 解析篇

　　

　　相关资料来自：http://speech.ee.ntu.edu.tw/~tlkagk/courses_ML17_2.html

　　首先提到 Why CNN for Image ?

　　

　　

　　

　　综合上述三个特点，我们可以看到图像识别有如下的特色：

　　

　　

　　===================================　　分割线　　=======================================================

　　以上就是整体上来感受下深度神经网络，接下来我们仔细分析下每一个部件：

　　1. Convolution Layer 

　　所谓卷积层，就是将两个矩阵进行卷积操作，这里的两个矩阵分别是指 卷积核（filter）和每一个与filter相同大小的图像区域。这里的卷积操作就是 点成（矩阵对应元素相乘）。

　　然后没执行一次这样的操作，就滑动一次filter，然后进行下一个区域的卷积操作，直至整幅图像被处理完毕。滑动的幅度，称为stride （步长）。如下图所示：

　　

　　然后再用另一组 filter 对该图像进行类似的处理。一张图像可以用多个卷积核来进行处理。上面提到的图像是 gray image，而对于彩色图像来说，是三个通道的。这个没有关系，我们将三个 filter 作为一组，分别对三个 channel 进行卷积，就可以了。如下图所示：

　　

　　2. Pooling Layer: 

　　所谓的池化层，就是对得到的 feature map 进行降采样处理，常见的有，mean, max pooling operation 等。即：在一个区域内，如：2*2 的区域，max pooling 就是选择一个 max value 来代表这个区域，其余的直接扔掉。mean 就是取这些 value 的平均值来代替这些。当然也可以同时进行 max 和 mean pooling 操作，来完成降采样的过程。

　　

　　需要说明的是，max pooling 其实并不是必须的，如：在AlphaGo 中，使用的网络结构并没有使用 max pooling layer，因为使用了这个层，就会丢失一定的信息，而实际上 棋盘丢失了某些信息，结果是无法想象的。因为这可能会导致不同的局面。。。这是李宏毅老师的解释。。。但是，我觉得，这只是整个分辨率降低了而已，没有那么大的影响吧？？？如果有小伙伴知道更详细的答案，请不吝赐教。

　　3. Fully Connected Layer: 

　　全连接层 也是常见的 CNN 组件，一般用来输出一组向量。而 fc layer 和 convolutional layer 可以看做是类似的操作，为何这么说呢？且看下图：

　　

　　上图中，我们将 filter 中不同的 weight 设置为不同的颜色，在进行卷积操作的时候，我们进行对应元素点乘操作，从而得到 3 。我们将对应图像区域中的元素标上标号可以看出，我们这里仅仅和 9 个输入元素进行了连接，而不是所有的元素。所以，这里 convolutional layer 是 sparse connected。同时，在移动之后的卷积操作也是类似，而且这两个过程是共享权重的，都分享了同一个 filter 1. 这样就可以降低参数的数量，使得训练和测试都可以尽量快速的执行。

　　

　　这里还有一个比较迷糊人的问题是，卷积层 出来的 feature map 是一个立方体矩阵，而 fc layer 处理的是 vector，这两者之间是怎么接起来的呢？看下图：

　　

　　是的，你没有看错，两者之间有一个 flatten 的操作，即：将 feature map 按照每一个 map 展开，然后拼接在一起，构成一个大的 vector，再进行处理。整个过程如下所示：

　　

　　4. 激活层：

　　常见的激活函数，有 sigmoid, ReLU, PReLU 等等。这些非线性函数被引入到 CNN 当中来，使得该模型具有非线性拟合能力。从而，可以执行更加复杂多样的任务。

　　==========================================　　分割线　　=================================================

　　CNN 常见的应用除了在图像领域之外，还有语音和自然语言领域。你可能比较纳闷，CNN 不是专门用来处理图像的吗？

　　宏观的来看，这只是一个执行 weighting operation 的网络，是可以处理任何 matrix 形式的东西的。例如：将语音和文本转化为 matrix 的形式，就可以利用 CNN 来进行特征的学习，从而完成后续的研究任务，像语音识别，等等。

　　

　　

========================　　完毕　　==============================

　　基础的图像识别的例子 ------ pytorch 版本：

　　

from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable

# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
                    help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
                    help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
                    help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
                    help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
                    help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
                    help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
                    help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
                    help='how many batches to wait before logging training status')
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()

torch.manual_seed(args.seed)
if args.cuda:
    torch.cuda.manual_seed(args.seed)

kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False, transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=args.test_batch_size, shuffle=True, **kwargs)

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        return F.log_softmax(x)

model = Net()
if args.cuda:
    model.cuda()

optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)

def train(epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data), Variable(target)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.data[0]))

def test():
    model.eval()
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data, volatile=True), Variable(target)
        output = model(data)
        test_loss += F.nll_loss(output, target, size_average=False).data[0] # sum up batch loss
        pred = output.data.max(1, keepdim=True)[1] # get the index of the max log-probability
        correct += pred.eq(target.data.view_as(pred)).cpu().sum()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

for epoch in range(1, args.epochs + 1):
    train(epoch)
    test()