pytorch: 学习笔记6, pytorch( 实现 )修改VGG16网络的全连接层为线性回归网络

修改VGG16网络的全连接层为线性回归，并用pytorch实现

说明：
a) vgg16最后一个卷积层14×14×512size，max polling后为7×7×512，进行flatten为7×7×512=25088，将其作为我们修改后全连接网络的输入；
b) 因为修改为线性回归网络，输出的值为连续的值，所以这里把vgg16的输出维度1000修改为1
修改后进行实验的网络为：input–>fc1–>fc2–>predict (25088–>4096–>4096–>1)

代码：

import time
import numpy as np
import torch
import torch.utils.data as Data
import torch.nn.functional as F


# 定义模型 : input-->fc1-->fc2-->predict
#          25088-->4096-->4096-->1
class FullConnectionNet(torch.nn.Module):
    def __init__(self, input, hidden1, hidden2, predict):
        super(FullConnectionNet, self).__init__()
        self.fc1 = torch.nn.Linear(input, hidden1)
        self.fc2 = torch.nn.Linear(hidden1, hidden2)
        self.predict = torch.nn.Linear(hidden2, predict)

    # forward 定义前向传播
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        y = self.predict(x)
        return y


def vgg16_fucll_connection_main():
    '''
    input: vgg16最后一个卷积层14*14*512size，max polling后为7*7*512，进行flatten为7*7*512=25088，将其作为我们全连接网络的输入。
    :return: 作为线性回归问题，把vgg16的预测输出 1000修改为1
    our net model: input-->fc1-->fc2-->predict
                25088-->4096-->4096-->1
           W*X=(4096*25088)*(25088*1)=(4096*1)
               (4096*4096)*(4096*1)=(4096*1)
               (1*4096)*(4096*1)=(1*1)
    '''
    # 1, 准备数据：25088输入特征features(10000组), labels:1(10000组)
    # W*X=(4096*25088)*(25088*1)=(4096*1)
    num_inputs = 25088
    num_samples = 10000
    hid1 = 4096
    hid2 = 4096
    predict = 1
    features = torch.randn(num_samples, num_inputs, dtype=torch.float32)
    labels = torch.tensor(np.random.rand(num_samples)+ np.random.normal(0, 0.01, size=num_samples), dtype=torch.float32)
    print(features.shape)  # torch.Size([10000, 25088])
    print(labels.shape)  # torch.Size([10000])

    # 2, 按照batch_size读取数据
    batch_size = 100
    # 将训练数据的特征和标签组合
    dataset = Data.TensorDataset(features, labels)  # PyTorch提供了data包来读取数据
    # 随机读取小批量
    data_iter = Data.DataLoader(dataset, batch_size, shuffle=True)
    # 查看一下读取的数据：
    # for X, y in data_iter:
    #     print(X.shape, y)
    #     break

    # 3.1, 定义模型 method1
    # fc_net = FullConnectionNet(num_inputs, hid1, hid2, predict)
    # print(fc_net)  # 使用print可以打印出网络的结构
    # # 3.2, 定义模型 method2: Sequential是一个有序的容器，网络层将按照在传入Sequential的顺序依次被添加到计算图中
    fc_net2 = torch.nn.Sequential(
        torch.nn.Linear(num_inputs, hid1),
        torch.nn.Linear(hid1, hid2),
        torch.nn.Linear(hid2, predict)
        )
    print(fc_net2)
    # for param in fc_net.parameters():  # 通过net.parameters()来查看模型所有的可学习参数，此函数将返回一个生成器。
    #     print(param)

    # 4。1, 初始化模型参数: 通过init.normal_将权重参数每个元素初始化为随机采样于均值为0、标准差为0.01的正态分布。偏差会初始化为零
    # torch.nn.init.normal_(fc_net.fc1.weight, mean=0, std=0.01)  # fc_net 的成员变量 linear
    # torch.nn.init.constant_(fc_net.fc1.bias, val=0)
    # torch.nn.init.normal_(fc_net.fc2.weight, mean=0, std=0.01)  # fc_net 的成员变量 linear
    # torch.nn.init.constant_(fc_net.fc2.bias, val=0)
    # 4.2 初始化模型参数 对应3.2: net[0]这样根据下标访问子模块的写法只有当net是个ModuleList或者Sequential实例时才可以
    torch.nn.init.normal_(fc_net2[0].weight, mean=0, std=0.01)
    torch.nn.init.constant_(fc_net2[0].bias, val=0)  # 也可以直接修改bias的data: net[0].bias.data.fill_(0)
    torch.nn.init.normal_(fc_net2[1].weight, mean=0, std=0.01)
    torch.nn.init.constant_(fc_net2[1].bias, val=0)

    # 5, 定义损失函数
    loss = torch.nn.MSELoss()  # 均方误差损失

    # 6, 定义优化算法。fc_net与fc_net2网络都可使用，这里我们选取fc_net2网络进行实验
    optimizer = torch.optim.SGD(fc_net2.parameters(), lr=0.03)
    print(optimizer)
    # # 调整学习率
    for param_group in optimizer.param_groups:
        param_group['lr'] *= 0.1  # 学习率为之前的0.1倍

    # 7, 训练模型: 通过调用optim实例的step函数来迭代模型参数
    num_epochs = 5
    for epoch in range(1, num_epochs + 1):
        for X, y in data_iter:
            output = fc_net2(X)
            l = loss(output, y.view(-1, 1))
            optimizer.zero_grad()  # 梯度清零，等价于net.zero_grad()
            l.backward()
            optimizer.step()
        print('epoch %d, loss: %f' % (epoch, l.item()))


if __name__ == '__main__':
    start_time = int(round(time.time() * 1000))
    vgg16_fucll_connection_main()
    end_time = int(round(time.time() * 1000))
    print('consume time: {cs} ms'.format(cs = end_time - start_time))

结果:

torch.Size([10000, 25088])
torch.Size([10000])
FullConnectionNet(
(fc1): Linear(in_features=25088, out_features=4096, bias=True)
(fc2): Linear(in_features=4096, out_features=4096, bias=True)
(predict): Linear(in_features=4096, out_features=1, bias=True)
)
Sequential(
(0): Linear(in_features=25088, out_features=4096, bias=True)
(1): Linear(in_features=4096, out_features=4096, bias=True)
(2): Linear(in_features=4096, out_features=1, bias=True)
)
SGD (
Parameter Group 0
dampening: 0
lr: 0.03
momentum: 0
nesterov: False
weight_decay: 0
)
epoch 1, loss: 0.228091
epoch 2, loss: 0.117855
epoch 3, loss: 0.099942
epoch 4, loss: 0.076183
epoch 5, loss: 0.059026
consume time: 363433 ms

VGG网络参考博文：
https://www.cnblogs.com/lfri/p/10493408.html