PyTorch应用实战五：实现二值化神经网络

文章目录

实验环境
二值化网络概述
实验内容
附：系列文章

实验环境

python3.6 + pytorch1.8.0

python 复制代码

import torch
print(torch.__version__)

1.8.0

二值化网络概述

二值化网络（BinaryNet）是一种深度学习网络类型，使用二进制（1和0）代替浮点数作为网络的输入和参数。这种网络类型由加拿大的Yaroslav Bulatov和Artem Babenko在2016年提出。二值化网络的独特之处在于它通过使用二进制数值（1或-1）来代替常规的浮点数，极大地减少了神经网络中的存储空间和计算量。这大大提高了神经网络的处理速度和效率，并使其在较小的处理器和设备上的应用更加可行。

在传统的神经网络中，每个神经元的输出值在0到1之间取值。网络的权重也是浮点数，可以在训练时根据错误来进行微调。但是，在二值化网络中，这些值被替换为-1和1。这种二进制表示法允许网络使用异或逻辑门和位移操作来代替复杂的乘法和加法运算，从而加快了计算速度。此外，网络的存储要求也减少了，因为每个神经元和权重只需要1个比特来表示。

虽然在计算速度和存储方面二值化网络有一定的优势，但在某些情况下，它会降低网络的准确性。二值化网络的主要问题在于，它不适合处理复杂的特征和数据集。因此，它通常用于解决图像分类、人脸识别和目标检测等简单任务。

在研究过程中，学者们提出了许多改进二值化网络的方法。例如，包括XNOR-Net、BinaryConnect、Hinton Binarized Neural Networks和Real-to-Binary Conversion等。这些方法可以使网络在保持二值化的优点的同时提高其准确性和适用性。

在实际应用中，二值化网络通常是一种加速深度学习推理的技术。例如，在移动设备上处理图像或运行深度学习模型时，二值化网络可以在不损失准确性的情况下体现出更高的速度和效率。

实验内容

python 复制代码

import torch
import torch.nn as nn
import math
from torch.autograd import Function
import torch.nn.functional as F
from torchvision import datasets, transforms

python 复制代码

class Binarize(Function):
    @staticmethod
    def forward(ctx, input):
        ctx.save_for_backward(input)
        return torch.sign(input + 1e-20)
    
    @staticmethod
    def backward(ctx, grad_output):
        input = ctx.saved_tensors[0]
        grad_output[input > 1] = 0
        grad_output[input < -1] = 0
        return grad_output

该代码实现了一个二值化函数，将输入张量中的每个元素变成-1或1，如果元素大于等于0则变成1，否则变成-1。该函数通过继承PyTorch的Function类来实现自定义反向传播。具体来说，该类实现了两个静态方法forward和backward，作用分别是前向传播和反向传播。

在前向传播中，函数使用torch.sign(input + 1e-20)将输入张量二值化，并将结果返回。需要注意的是，在计算sign时，为了避免输入为0的情况，添加了1e-20的偏移量。

在反向传播中，函数首先从上下文中获取之前保存的输入张量input。然后对于所有大于1或小于-1的元素，在梯度grad_output中将其对应位置上的梯度设为0，表示这些位置上的输入不应该对梯度做出贡献。最后返回更新后的梯度grad_output。

总的来说，该函数简单易懂，用途广泛，可以用于二值化卷积神经网络中的权重或激活值。

ctx.save_for_backward(input)是将输入保存在上下文ctx对象中，以供后续的反向传播使用。在PyTorch中，要实现自定义的反向传播需要重载torch.autograd.Function中的forward和backward方法，使用ctx.save_for_backward(input)可以将forward方法中的输入input保存下来，在backward方法中可以使用ctx.saved_tensors获取到这些保存的张量数据，进而计算梯度。
@staticmethod 是 Python 中的一个装饰器（decorator），它用于定义一个静态方法。静态方法是与类相关联的方法，但是不需要访问类或实例的状态，也就是说，它们在执行时不依赖于实例的状态，因此可以在不创建实例的情况下直接调用。通过在方法定义上添加@staticmethod装饰器，可以将一个普通函数声明为静态方法。

python 复制代码

class BinarizedLinear(nn.Module):
    def __init__(self, in_features, out_features, binarize_input=True):
        super(BinarizedLinear, self).__init__()
        self.binarize_input = binarize_input
        self.weight = nn.Parameter(torch.Tensor(out_features, in_features))
        nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
        
    def forward(self, x):
        if self.binarize_input:
            x = Binarize.apply(x)    #调用静态方法
        w = Binarize.apply(self.weight)
        out = torch.matmul(x, w.t())
        return out

这段代码是实现了一个二值化的全连接层 BinarizedLinear，继承自 PyTorch 的 nn.Module。主要包含以下几个部分：

构造函数：接收两个参数，输入特征数和输出特征数，并初始化权重参数 self.weight。其中，参数 binarize_input 表示是否对输入数据进行二值化处理。
forward 函数：接收输入数据 x，如果 binarize_input 为 True，则对输入数据进行二值化处理，然后对权重参数也进行二值化处理，并使用矩阵乘法计算输出值 out。
Binarize 类：定义了一个自定义的二值化操作 Binarize.apply，是一个继承自 PyTorch 的 autograd.Function，可以实现自动求导。其作用是将输入数据 x 的取值二值化为 -1 或 1，根据具体取值的正负号。

通过在网络中使用 BinarizedLinear 层，可以减少模型的计算量，提高模型的计算速度和效率，但可能会降低模型的准确率。

python 复制代码

model = nn.Sequential(
    BinarizedLinear(784, 2048, False),
    nn.BatchNorm1d(2048),
    BinarizedLinear(2048, 2048),
    nn.BatchNorm1d(2048),
    BinarizedLinear(2048, 2048),
    nn.Dropout(0.5),
    nn.BatchNorm1d(2048),
    nn.Linear(2048, 10)
)

optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=40, gamma=0.1)

这是一个使用BinarizedLinear层构建的神经网络模型，该层用于二值化输入和权重。该模型共有6个层，分别是3个BinarizedLinear层、2个BatchNorm1d层和1个普通的线性层。其中，第一个BinarizedLinear层的输入大小为784，输出大小为2048；第二个和第三个BinarizedLinear层的输入和输出大小都是2048。最后一个普通线性层用于将2048个输出映射到10个输出，对应10个分类。在第三个BinarizedLinear层和第四个BatchNorm1d层之间添加了一个50%的dropout层，以减少过拟合。

优化器使用Adam优化器，学习率为0.01，使用StepLR调度器每过40个epoch将学习率调整为原来的0.1倍，以加速收敛。

python 复制代码

train_batch_size = 100  #一共60000个数据,100个数据一组,一共600组(N=100)
test_batch_size = 100   #一共10000个数据,100个数据一组,一共100组(N=100)
# 训练集
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST(
        './data',train=True,download=True,  
        transform=transforms.Compose([
            transforms.ToTensor(),  #转为tensor
            transforms.Normalize(0.5,0.5) #正则化
        ])
    ),
    batch_size = train_batch_size, shuffle=True  #打乱位置
)
# 测试集
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST(
        './data',train=False,download=True,
        transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize(0.5,0.5)
        ])
    ),
    batch_size = test_batch_size, shuffle=False
)

这段代码实现了通过PyTorch的DataLoader加载MNIST数据集。MNIST是一个手写数字数据集，包含60,000张28x28的训练图像和10,000张测试图像，每张图像代表一个从0到9中的数字。

首先定义了两个超参数train_batch_size和test_batch_size，这是训练集和测试集每组数据的大小。在这里分别为100，也就是每次加载100张图片进行训练或测试。

然后定义了训练集和测试集的DataLoader，使用MNIST类加载数据集，参数中train=True表示加载训练集，train=False表示加载测试集。同时也指定了加载的路径和应用的预处理操作，包括将图像转换为张量和进行正则化处理。

最后，指定了batch_size和shuffle参数，表示每次加载的图像数量和是否打乱图像的顺序。在训练过程中，通常会在每个epoch结束时打乱图像的顺序，以保证模型可以学习到更多的变化和模式。在测试过程中，没有必要打乱图像的顺序，因为我们只需要评估模型的性能。

python 复制代码

epochs = 100
interval = 100

for epoch in range(epochs):
    for i, (data, label) in enumerate(train_loader):
        model.train()
        optimizer.zero_grad()
        output = model(data.view(-1, 28*28))
        loss = F.cross_entropy(output, label)  #交叉熵函数
        loss.backward()   #反向求导
        optimizer.step()
        
        if i % interval == 0:
            print("Epoch %03d [%03d/%03d]\tLoss:%.4f"%(epoch, i, len(train_loader), loss.item()))
    correct_num = 0
    total_num = 0
    with torch.no_grad():
        for data, label in test_loader:
            model.eval()
            output = model(data.view(-1, 28*28))
            pred = output.max(1)[1]
            correct_num += (pred == label).sum().item()
            total_num += len(data)
    acc = correct_num / total_num
    print('...Testing @ Epoch %03d\tAcc:%.4f'%(epoch, acc))
    
    scheduler.step()

Epoch 000 [000/600]	Loss:2.4242
Epoch 000 [100/600]	Loss:0.7715
Epoch 000 [200/600]	Loss:0.6427
Epoch 000 [300/600]	Loss:0.6404
Epoch 000 [400/600]	Loss:0.5750
Epoch 000 [500/600]	Loss:0.1281
...Testing @ Epoch 000	Acc:0.9402
Epoch 001 [000/600]	Loss:0.1153
Epoch 001 [100/600]	Loss:0.3760
Epoch 001 [200/600]	Loss:0.2282
Epoch 001 [300/600]	Loss:0.3495
Epoch 001 [400/600]	Loss:0.0987
Epoch 001 [500/600]	Loss:0.2286
...Testing @ Epoch 001	Acc:0.9598
Epoch 002 [000/600]	Loss:0.1307
Epoch 002 [100/600]	Loss:0.0409
Epoch 002 [200/600]	Loss:0.2278
Epoch 002 [300/600]	Loss:0.1454
Epoch 002 [400/600]	Loss:0.0510
Epoch 002 [500/600]	Loss:0.1283
...Testing @ Epoch 002	Acc:0.9661
Epoch 003 [000/600]	Loss:0.0372
Epoch 003 [100/600]	Loss:0.0778
Epoch 003 [200/600]	Loss:0.0903
Epoch 003 [300/600]	Loss:0.0772
Epoch 003 [400/600]	Loss:0.0523
Epoch 003 [500/600]	Loss:0.1434
...Testing @ Epoch 003	Acc:0.9603
Epoch 004 [000/600]	Loss:0.0792
Epoch 004 [100/600]	Loss:0.2278
Epoch 004 [200/600]	Loss:0.0707
Epoch 004 [300/600]	Loss:0.1063
Epoch 004 [400/600]	Loss:0.1302
Epoch 004 [500/600]	Loss:0.1531
...Testing @ Epoch 004	Acc:0.9700
Epoch 005 [000/600]	Loss:0.1077
Epoch 005 [100/600]	Loss:0.0279
Epoch 005 [200/600]	Loss:0.1569
Epoch 005 [300/600]	Loss:0.0495
Epoch 005 [400/600]	Loss:0.0547
Epoch 005 [500/600]	Loss:0.1252
...Testing @ Epoch 005	Acc:0.9677
Epoch 006 [000/600]	Loss:0.0139
Epoch 006 [100/600]	Loss:0.0064
Epoch 006 [200/600]	Loss:0.0180
Epoch 006 [300/600]	Loss:0.0480
Epoch 006 [400/600]	Loss:0.0868
Epoch 006 [500/600]	Loss:0.0651
...Testing @ Epoch 006	Acc:0.9648
Epoch 007 [000/600]	Loss:0.0300
Epoch 007 [100/600]	Loss:0.0104
Epoch 007 [200/600]	Loss:0.0738
Epoch 007 [300/600]	Loss:0.0654
Epoch 007 [400/600]	Loss:0.1252
Epoch 007 [500/600]	Loss:0.1658
...Testing @ Epoch 007	Acc:0.9625
Epoch 008 [000/600]	Loss:0.1689
Epoch 008 [100/600]	Loss:0.0250

这段代码是一个简单的神经网络模型的训练和测试过程。
首先定义了两个变量epochs和interval，分别表示训练过程中的总轮数和每训练interval个batch就输出一次训练结果。
然后使用了一个双重循环，外层循环遍历epochs轮，内层循环遍历训练数据集中的所有batch。在每个batch中，首先将模型设为训练模式，然后将优化器的梯度清零，接着将模型输入当前batch的数据并得到输出，计算损失值并进行反向传播求导，最后使用优化器更新模型参数。
当训练完interval个batch时，输出当前轮的训练结果，其中包括当前轮数、当前batch数、总batch数和当前batch的损失值。
接着，在训练完成一轮后，使用测试数据集对模型进行测试。首先将模型设置为评估模式，然后遍历测试数据集中的所有数据，将模型输入测试数据并得到输出，计算预测结果并与真实标签进行比较，统计正确预测的数量和总数量，最后计算测试集的准确率。
最后，使用scheduler.step()函数更新学习率。scheduler是调整学习率的一个函数，根据不同的策略进行学习率的调整，例如每隔一定轮数降低学习率等。这里使用的是StepLR函数，每隔一定轮数降低学习率。

附：系列文章

序号	文章目录	直达链接
1	PyTorch应用实战一：实现卷积操作	https://want595.blog.csdn.net/article/details/132575530
2	PyTorch应用实战二：实现卷积神经网络进行图像分类	https://want595.blog.csdn.net/article/details/132575702
3	PyTorch应用实战三：构建神经网络	https://want595.blog.csdn.net/article/details/132575758
4	PyTorch应用实战四：基于PyTorch构建复杂应用	https://want595.blog.csdn.net/article/details/132625270
5	PyTorch应用实战五：实现二值化神经网络	https://want595.blog.csdn.net/article/details/132625348
6	PyTorch应用实战六：利用LSTM实现文本情感分类	https://want595.blog.csdn.net/article/details/132625382