pytorch部分知识点笔记

pytorch------cpu与gpu load时相互转化 torch.load(map_location=)

假设我们只保存了模型的参数(model.state_dict())到文件名为modelparameters.pth, model = Net()
1. cpu -> cpu或者gpu -> gpu:
checkpoint = torch.load('modelparameters.pth')
model.load_state_dict(checkpoint)
2. cpu -> gpu 1
torch.load('modelparameters.pth', map_location=lambda storage, loc: storage.cuda(1))
3. gpu 1 -> gpu 0
torch.load('modelparameters.pth', map_location={'cuda:1':'cuda:0'})
4. gpu -> cpu
torch.load('modelparameters.pth', map_location=lambda storage, loc: storage)

'''
图像相关层学习
cv2 读进来的bgr 格式，plt 显示是以rgb 格式，所以颜色就反着了。plt 之前，先将图片转为rgb 即可。
cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
'''
from PIL import Image
from torchvision.transforms import ToTensor, ToPILImage
import cv2
import numpy as np
import torch
from torch import nn
from torch.autograd import Variable as V

to_tensor = ToTensor()
to_pil = ToPILImage()
lena = Image.open('image/lena1.jpg')
lena1 = cv2.imread('image/lena1.jpg',0)
print(lena.size)
print(to_tensor(lena).shape)
lena2 = to_tensor(lena).unsqueeze(0)#batchsize,c,h,w
print(lena2.shape)
'''
print(lena.size)#w,h
print(to_tensor(lena).shape)#c,h,w
print(lena2.shape)
lena3 = np.array(lena).astype(np.float32).shape#lena--->lena1
print(lena3)#h,w,c
'''
#锐化卷积核
kernel = torch.ones(3,3)/-9
kernel[1][1] = 1
conv = nn.Conv2d(1,1,(3,3),1,bias=False)
conv.weight.data = kernel.view(1,1,3,3)#初始化权重
out = conv(V(lena2))
Image._show(to_pil(out.data.squeeze(0)))#该卷积层对图像进行了锐化处理，处理后的图像转成Image图像展示出来。
#池化层
pool = nn.AvgPool2d(2,2)
print(list(pool.parameters()))#池化层没有可学习的参数
out = pool(V(lena2))
#Image._show(to_pil(out.data.squeeze(0)))#下采样

nn.functional 和 nn.Module模块的区别

'''
nn.functional 和 nn.Module模块的区别
nn.Module实现的layers是一个特殊的类，都是由class layer(nn.module)定义，会自动提取学习的参数，而nn.functional更像一个纯函数
对有模型可以学习的参数，最好用nn.moudle,如conv层和linear层，对于没有参数额激励层和池化层推荐使用nn.functional
'''
import warnings
warnings.filterwarnings("ignore")
from torch.autograd import variable as V
from torch.nn import functional as F
import torch.nn as nn
import torch
input = V(torch.randn(2,3))
model = nn.Linear(3,4)
output1 = model(input)
output2 = F.linear(input,model.weight,model.bias)
print(output1 == output2)
b = F.relu(input)
b2 = nn.ReLU()(input)
print(b == b2)

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(3,6,5)
        self.conv2 = nn.Conv2d(6,16,5)
        self.fc1 = nn.Linear(16*5*5,120)
        self.fc2 = nn.Linear(120,84)
        self.fc3 = nn.Linear(84,10)
    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        x = F.max_pool2d(F.relu(self.conv2(x)),(2,2))
        x = x.view(-1,16*5*5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        return x
net = Net()
print(net(V(torch.randn(3,3,53,53))))
#不具备可以学习的参数的层（激励层，池化层等），也可以用nn.module，但是需要自定义手动实现
class MyLinear(nn.Module):
    def __init__(self):
        super(MyLinear,self).__init__()
        self.weight = nn.parameter(torch.randn(3,4))
        self.bias = nn.parameter(torch.zeros(3))
        def forward(self,input,weight,bias):
            return F.linear(input,weight,bias)

网络权重的初始化除了使用module的自学习的参数外，还可以自己去定义

'''
自定义初始化
在深度学习中nn.module已经有了比较好的初始化策略，一般不用我们考虑，但是也可以自定义进行初始化
'''
from torch.nn import init
import torch.nn as nn
import torch
import warnings
import math
warnings.filterwarnings("ignore")
linear = nn.Linear(3,4)
torch.manual_seed(1) #种子，进行随机初始化
init.xavier_normal(linear.weight) # 对权重进行初始化
print(linear.weight)
std = math.sqrt(2)/math.sqrt(7)
linear.weight.data.normal_(0,std) #指明了均值和方差
print(linear.weight)

 保存模型，使用GPU，并行计算

'''
保存模型
'''
torch.save(net.state_dict(),"net.pth")#加载
net2.load_state_dict(torch.load("net.pth"))#保存
'''
moudle放在GPU上分为两步，一个是模型放在GPU上，另一个是数据放在GPU上
'''
model = model.cuda()
input = input.cuda()
'''
并行计算，使用多个GPU
'''
#method 1
new_net = nn.DataParallel(net,device_ids=[0,1])
output = new_net(input)
#method 2
output = nn.parallel.data_parallel(net,input,device_ids=[0,1])

 

Python中的*args和**kwargs

 

 

 

统计参数量

?

1 2 3 4 5 6

def print_network(net):  #统计模型参数量     num_params = 0     for param in net.parameters():         num_params += param.numel()     print(net)     print('Total number of parameters: %d' % num_params)

　　

 

 

 网络初始化

def define_FewShotNet(pretrained=False, model_root=None, which_model='Conv64', norm='batch', init_type='normal',
                      use_gpu=True, shot_num=5, **kwargs):
    FewShotNet = None
    norm_layer = get_norm_layer(norm_type=norm)

    if use_gpu:
        print(torch.cuda.is_available())

    if which_model == 'Conv64F':
        FewShotNet = Conv_64F(norm_layer=norm_layer, **kwargs)
    else:
        raise NotImplementedError('Model name [%s] is not recognized' % which_model)
    init_weights(FewShotNet, init_type=init_type)

    if use_gpu:
        FewShotNet.cuda()

    if pretrained:
        FewShotNet.load_state_dict(model_root)

    return FewShotNet

确定使用的正则化方法

def get_norm_layer(norm_type='instance'): #确定使用的正则化方法
    if norm_type == 'batch':
        norm_layer = functools.partial(nn.BatchNorm2d, affine=True)
    elif norm_type == 'instance':
        norm_layer = functools.partial(nn.InstanceNorm2d, affine=False)
    elif norm_type == 'none':
        norm_layer = None
    else:
        raise NotImplementedError('normalization layer [%s] is not found' % norm_type)
    return norm_layer

权重初始化

def weights_init_normal(m):
    classname = m.__class__.__name__
    # print(classname)
    if classname.find('Conv2d') != -1:
        init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find('Linear') != -1:
        init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find('BatchNorm2d') != -1:
        init.normal_(m.weight.data, 1.0, 0.02)
        init.constant_(m.bias.data, 0.0)


def weights_init_xavier(m):
    classname = m.__class__.__name__
    # print(classname)
    if classname.find('Conv') != -1:
        init.xavier_normal_(m.weight.data, gain=0.02)
    elif classname.find('Linear') != -1:
        init.xavier_normal_(m.weight.data, gain=0.02)
    elif classname.find('BatchNorm2d') != -1:
        init.normal_(m.weight.data, 1.0, 0.02)
        init.constant_(m.bias.data, 0.0)


def weights_init_kaiming(m):
    classname = m.__class__.__name__
    # print(classname)
    if classname.find('Conv') != -1:
        init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
    elif classname.find('Linear') != -1:
        init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
    elif classname.find('BatchNorm2d') != -1:
        init.normal_(m.weight.data, 1.0, 0.02)
        init.constant_(m.bias.data, 0.0)


def weights_init_orthogonal(m):
    classname = m.__class__.__name__
    print(classname)
    if classname.find('Conv') != -1:
        init.orthogonal_(m.weight.data, gain=1)
    elif classname.find('Linear') != -1:
        init.orthogonal_(m.weight.data, gain=1)
    elif classname.find('BatchNorm2d') != -1:
        init.normal_(m.weight.data, 1.0, 0.02)
        init.constant_(m.bias.data, 0.0)


def init_weights(net, init_type='normal'):   #权重的初始化部分
    print('initialization method [%s]' % init_type)
    if init_type == 'normal':
        net.apply(weights_init_normal)
    elif init_type == 'xavier':
        net.apply(weights_init_xavier)
    elif init_type == 'kaiming':
        net.apply(weights_init_kaiming)
    elif init_type == 'orthogonal':
        net.apply(weights_init_orthogonal)
    else:
        raise NotImplementedError('initialization method [%s] is not implemented' % init_type)

使用