2_pytorch_base

---

1.模型处理

1.1)模型的生成

在深度学习中，torchvison.models提供了众多经典的网络结构与预训练模型，
可以根据需求，直接利用这些模型，在torchvison官网中可以看到这些模型的加载方法

以vgg为例，展示模型的加载:

import torch
import torchvision.models as models
"""加载模型"""
vgg=models.vgg16()
#打印模型结构
# print(vgg)
#打印vgg特征层
# print(len(vgg.features))
# print(vgg.features)
#打印特征层的第一层
# print(vgg.features[0])
#打印vgg分类层
# print(len(vgg.classifier))
# print(vgg.classifier)
#打印分类层的某一部分
# print(vgg.classifier[:3])

1.2)加载预训练模型

对于一些任务，有时由于数据有限和时间的关系，我们很难从零开始训练一个模型。因此，我们常用的一个方法是 Fine-tune(微调)。微调就是利用别人在一些数据集上训练好的模型，在自己数据集上训练自己的模型。
在具体使用时，有以下两种做法：
1）直接利用torchvision.models中自带的模型，只需在调用时赋予参数pretained为True即可，此时不仅可以得到网络结构，还可以得到训练好的各权重参数。

import torch
import torchvision.models as models
vgg=models.vgg16(pretrained=True)

2）如果想使用自己本地预训练的模型，或者之前训练过的模型，则可以通过**model.load_state_dict()**函数操作。

import torch
import torchvision.models as models
vgg=models.vgg16()
#加载本地训练好的网络参数权重
state_dict=torch.load("model_path")
#遍历预训练模型的关键字，如果出现在vgg中，则加载模型参数
vgg.load_state_dict({k:i for k,i in state_dict if k in vgg.state_dict()})

在图像处理中，卷积层的任务为提取图像特征，不同任务，卷积层作用非常类似，所以我们可以通过冻住部分卷积层，修改适合自己的全连接层，再在本地仅仅用数据训练全连接层，只是对卷积层进行微调或不进行参数学习。

vgg=models.vgg16()
n=10
#冻住前10层
for layer in range(n):
    for p in vgg.features[layer].parameters():
        p.requires_grad=False

1.3）模型保存

模型保存可以通过**torch.save()函数来实现，我们可以保存网络模型，优化器，这些对象的当前状态数据可以通过自身state_dict()**来获取。

torch.save(
    {
        "models":model.state_dict()
         "optimizer":optimizer.state_dict()
    }
        ,"model_path"
)

1.4)模型，数据可视化

tensorboardX功能强大，能够支持数据，图像，直方图，文本，图等可视化
1）安装方法：

1.安装TensorFlow：注意要1.9版本以下
pip install tensorflow==1.15.0
2.安装tensorboardX
pip install tensorboardX

2）使用方法
导入tensorboardX，实例化SummaryWriter类，指明记录日志路径信息。

from tensorboardX import SummaryWriter
#实例化SummaryWriter,并指明日志存放路径。当前路劲下不存在，则会自动创建
writer=SummaryWriter(log_dir="your_log_path")
#调用实例
writer.add_xxx()
#关闭writer
writer.close()

"""说明:
1.windows环境下注意路径斜线方向
2.SummaryWriter的格式：
    SummaryWriter(log_dir= ,comment="")
logdir指明日志存储路径
comment在文件名后加上后缀
3.调用实例：
add_xxx(tag_name,object,iteration)
即：标签，记录对象，迭代次数
4.启动tensorboardX服务
在命令行中输入：
tensorboard --logdir=your_log_path --port 6006
注意这里填绝对路径，如果cd切换到log目录下，则可以填相对路径
5.web展示
在浏览器中输入
http://localhost:6006
便可看到可视化图形"""

3）实例化

#一.可视化神经网络模型
#1.导入模块
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from tensorboardX import SummaryWriter
#2.搭建网络
class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(in_channels=1,out_channels=16,kernel_size=5,stride=1,padding=2),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )
        self.conv2=nn.Sequential(nn.Conv2d(in_channels=16,out_channels=32,kernel_size=5,stride=1,padding=2),
                                 nn.ReLU(),nn.MaxPool2d(kernel_size=2))
        self.out=nn.Linear(32*7*7,10)
    def forward(self,x):
        x=self.conv1(x)
        x=self.conv2(x)
        x=x.view(x.size(0),-1)
        x=self.out(x)
        return x
#3.把模型保存为graph
#定义输入
input=torch.rand(32,1,28,28)
#实例化网络
Net=CNN()
#将模型保存为graph
with SummaryWriter(log_dir="logs",comment="cnn") as w:
    w.add_graph(Net,input)

运行结果：

#二.可视化损失值
"""构建数据"""
train_data1=torch.linspace(-3,3,100)
train_label1=torch.sin(train_data1)
train_data=torch.unsqueeze(train_data1,1)
train_label=torch.unsqueeze(train_label1,1)
dataset=TensorDataset(train_data,train_label)
data_loader=DataLoader(dataset,batch_size=16,shuffle=True)
"""搭建两层神经网络"""
Net=nn.Sequential(nn.Linear(1,10),nn.ReLU(),nn.Linear(10,1))
#定义损失函数与优化器
optimizer=optim.SGD(Net.parameters(),lr=0.001)
criterion=nn.MSELoss()
epoches=5000
#实例化SummaryWriter类
writer=SummaryWriter(log_dir="log/regression")
#训练模型
for epoch in range(epoches):
    losses=[]
    for x,y in data_loader:
        output=Net(x)
        loss=criterion(output,y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        losses.append(loss.data)
    mean_loss=np.mean(np.array(losses))
    writer.add_scalar("训练损失值",mean_loss,epoch)
    if epoch%500==0:
        print("epoch:{} | loss:{}".format(epoch,mean_loss))
predict=torch.squeeze(Net(train_data).data,1).numpy()
plt.plot(train_data1,predict,c="black")
plt.show()

运行结果：