前言
本文介绍利用Pytorch搭建Lenet模型，以cifar10为例，具体流程见博客
https://blog.csdn.net/qq_43542339/article/details/106058752

Lenet

代码

由于cifar10为三通道图像，故self.conv1中in_channels参数为3

class Lenet_torch(nn.Module):
    def __init__(self):
        super(Lenet_torch,self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=6,kernel_size=5,stride=1)  #output:28*28*6
        self.maxpool1 = nn.MaxPool2d(2)  #output:14*14*6
        self.conv2 = nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5,stride=1)  #output:10*10*16
        self.maxpool2 = nn.MaxPool2d(2)  #output:5*5*16
        self.fc1 = nn.Linear(in_features=16*5*5,out_features=120)
        self.fc2 = nn.Linear(in_features=120,out_features=84)
        self.fc3 = nn.Linear(in_features=84,out_features=10)  #out_features为类别数

    def forward(self,x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = self.maxpool1(x)

        x = x.view(x.size(0),-1)

        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)

        return x



print(net)查看模型


运行成功，说明网络模型搭建成功



小结

Lenet网络较为简单，搭建起来很容易，注意一下这里不同于VGG，没有利用padding进行填充（当然自己使用的时候完全可以更改）
如有不足还请多多指教

前言
最近在学习pytorch框架，跟着敲总觉得少了点什么，就搭建一个网络模型试试，选择VGG16模型，数据集为cifar10（仅用来测试网络能运行）
加载数据
此处加载数据方式与官方教程一致，可忽略。
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False)
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

VGG16

模型：博客有介绍：https://blog.csdn.net/qq_43542339/article/details/104486300
代码：

class VGG16_torch(nn.Module):
    def __init__(self):
        super(VGG16_torch,self).__init__()

        # GROUP 1
        self.conv1_1 = nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,stride=1,padding=(1,1)) #output:32*32*64
        self.conv1_2 = nn.Conv2d(in_channels=64,out_channels=64 ,kernel_size=3,stride=1,padding=(1,1))#output:32*32*64
        self.maxpool1 = nn.MaxPool2d(2)#池化后长宽减半 output:16*16*64

        # GROUP 2
        self.conv2_1 = nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,stride=1,padding=(1,1))#output:16*16*128
        self.conv2_2 = nn.Conv2d(in_channels=128,out_channels=128,kernel_size=3,stride=1,padding=(1,1))#output:16*16*128
        self.maxpool2 = nn.MaxPool2d(2)#池化后长宽减半 output:8*8*128

        # GROUP 3
        self.conv3_1 = nn.Conv2d(in_channels=128,out_channels=256,kernel_size=3,stride=1,padding=(1,1))#output:8*8*256
        self.conv3_2 = nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=(1,1))#output:8*8*256
        self.conv3_3 = nn.Conv2d(in_channels=256,out_channels=256,kernel_size=1,stride=1)#output:8*8*256
        self.maxpool3 = nn.MaxPool2d(2)  # 池化后长宽减半 output:4*4*256

        # GROUP 4
        self.conv4_1 = nn.Conv2d(in_channels=256,out_channels=512,kernel_size=3,stride=1,padding=1)#output:4*4*512
        self.conv4_2 = nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1)#output:4*4*512
        self.conv4_3 = nn.Conv2d(in_channels=512,out_channels=512,kernel_size=1,stride=1)#output:4*4*512
        self.maxpool4 = nn.MaxPool2d(2)  # 池化后长宽减半 output:2*2*512

        # GROUP 5
        self.conv5_1 = nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1)  # output:14*14*512
        self.conv5_2 = nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1)  # output:14*14*512
        self.conv5_3 = nn.Conv2d(in_channels=512, out_channels=512, kernel_size=1, stride=1)  # output:14*14*512
        self.maxpool5 = nn.MaxPool2d(2)  # 池化后长宽减半 output:1*1*512

        self.fc1 = nn.Linear(in_features=512*1*1,out_features=256)
        self.fc2 = nn.Linear(in_features=256,out_features=256)
        self.fc3 = nn.Linear(in_features=256,out_features=10)

    #定义前向传播
    def forward(self,x):
        input_dimen = x.size(0)

        #GROUP 1
        output = self.conv1_1(x)
        output = F.relu(output)
        output = self.conv1_2(output)
        output = F.relu(output)
        output = self.maxpool1(output)

        #GROUP 2
        output = self.conv2_1(output)
        output = F.relu(output)
        output = self.conv2_2(output)
        output = F.relu(output)
        output = self.maxpool2(output)

        #GROUP 3
        output = self.conv3_1(output)
        output = F.relu(output)
        output = self.conv3_2(output)
        output = F.relu(output)
        output = self.conv3_3(output)
        output = F.relu(output)
        output = self.maxpool3(output)

        #GROUP 4
        output = self.conv4_1(output)
        output = F.relu(output)
        output = self.conv4_2(output)
        output = F.relu(output)
        output = self.conv4_3(output)
        output = F.relu(output)
        output = self.maxpool4(output)

        #GROUP 5
        output = self.conv5_1(output)
        output = F.relu(output)
        output = self.conv5_2(output)
        output = F.relu(output)
        output = self.conv5_3(output)
        output = F.relu(output)
        output = self.maxpool5(output)

        output = output.view(x.size(0),-1)

        output = self.fc1(output)
        output = self.fc2(output)
        output = self.fc3(output)
        
		#返回输出
        return output


训练
训练过程与官方教程相同，可忽略
epoch = 10 #训练次数
learning_rate = 1e-4 #学习率

net = VGG16_torch()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=learning_rate)

for epoch in range(epoch):  #迭代
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        #初始化梯度
        optimizer.zero_grad()

        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 打印loss
        running_loss += loss.item()
        if i % 20 == 19:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.5f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

运行结果
能跑说明模型没问题
小结

VGG网络模型搭建时注意1*1卷积核可以不需要加padding（复制粘贴注意一下）
网络模型参数根据输入图像进行调整，当特征图尺寸很小时便可停止卷积，展平后接FC层输出。

Word更改默认模板+自定义适用于自己风格的模板


Office默认模板位置：

%AppData%\Microsoft\Templates

复制以上内容到【文件资源管理器】地址栏>>回车。即可看到下图名称为Normal.dotm的Word模板。




右击该模板文件>>选择【打开】，即可打开Word默认模板；【P.S.双击是新建Word文档】
在里面直接可以【按自己的需求】修改Word【默认应用样式、页面布局设置(页边距、页面大小)、默认表格属性等等……】。

以挖矿为模型的0-1背包问题（非递归）

上次写了以挖矿为模型的0-1背包问题，这次为递归版本，可以正确输出结果，但是需要建立中间数组存储递归过程中产生的结果，否则程序超时。
#include<stdio.h>
#define N 5
#define M 10
int max(int a, int b)
{
	if (a > b)
		return a;
	else
		return b;
}

int peopleneeded[N + 1] = {0, 2, 3, 1, 4, 2};//if we want to dig No. i gold mine, the people we have to use.
	int goldprice[N + 1] = {0, 5, 4, 3, 7, 6};//if we dig No. i gold mine, the value we can gain.

int TV (int i, int j)
{
	if (j == 0)
		return 0;
	if (i == 1 && j >= peopleneeded[1])
		return goldprice[1];//"the number of workers is 0" and "the number of gold mine is 1" are boundary conditions.
	if (j < peopleneeded[i])
		return TV(i - 1, j);
	else
		return max(TV(i - 1, j), TV(i - 1, j - peopleneeded[i]) + goldprice[i]);
}

int main()
{
	printf("%d", TV(N, M));
	return 0;
}