pytorch学习

1. nn.Module

我们在定义自已的网络的时候, 需要继承nn.Module类, 并重新实现构造函数__init__构造函数和forward这两个方法。
技巧：

1. 一般把网络中具有可学习参数的层（如全连接层、卷积层等）放在构造函数__init__()中，当然我也可以吧不具有参数的层也放在里面
2. forward方法是必须要重写的，它是实现模型的功能，实现各个层之间的连接关系的核心
3. 一般把不具有可学习参数的层(如ReLU、dropout、BatchNormanation层)可放在构造函数中，也可不放在构造函数中，如果不放在构造函数__init__里面，
   则在forward方法里面可以使用nn.functional来代替。

class ANN(nn.Module):
    def __init__(self, args, name):
        super(ANN, self).__init__() #调用父类的构造函数
        self.name = name
        self.len = 0
        self.loss = 0
        self.fc1 = nn.Linear(args.input_dim, 20)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        self.dropout = nn.Dropout()
        self.fc2 = nn.Linear(20, 20)
        self.fc3 = nn.Linear(20, 20)
        self.fc4 = nn.Linear(20, 1)

    def forward(self, data):
        x = self.fc1(data)
        x = self.sigmoid(x)
        x = self.fc2(x)
        x = self.sigmoid(x)
        x = self.fc3(x)
        x = self.sigmoid(x)
        x = self.fc4(x)
        x = self.sigmoid(x)

        return x
# 可以替换为
import torch.nn.functional as F
class ANN(nn.Module):
    def __init__(self, args, name):
        super(ANN, self).__init__() #调用父类的构造函数
        self.name = name
        self.len = 0
        self.loss = 0
        self.fc1 = nn.Linear(args.input_dim, 20)
        # self.relu = nn.ReLU()
        # self.sigmoid = nn.Sigmoid()
        # self.dropout = nn.Dropout()
        self.fc2 = nn.Linear(20, 20)
        self.fc3 = nn.Linear(20, 20)
        self.fc4 = nn.Linear(20, 1)

    def forward(self, data):
        x = self.fc1(data)
        # x = self.sigmoid(x)
        x = F.sigmoid(x)
        x = self.fc2(x)
        # x = self.sigmoid(x)
        x = F.sigmoid(x)
        x = self.fc3(x)
        # x = self.sigmoid(x)
        x = F.sigmoid(x)
        x = self.fc4(x)
        # x = self.sigmoid(x)
        x = F.sigmoid(x)

        return x

2. .to

一、转换数据为浮点数

(张量不执行inplace操作，因此要重新赋值)

tensorX = torch.ones((3,3))
tensorX.to(torch.float64)

二、将张量放至gpu

# (张量不执行inplace操作，因此要重新赋值)
tensorX = tensorX.to('cuda')
# 指定gpu
tensorX = tensorX.to('cuda:0')
@以下是另一种方法
device = torch.device('cuda:0')
tensorX = tensorX.to(device)

三、将模型放至gpu

# (模型执行inplace操作，因此不需要重新赋值)
net.to('cuda')
# 指定gpu
net.to('cuda:0')
@以下是另一种方法
device = torch.device('cuda:0')
net.to(device)

1.1 gpu数量尽量为偶数，避免异常中断
1.2 数据量比较小时，多gpu没有单gpu好，而单gpu没有cpu好
1.3 若内存不够大，使用多gpu训练时可设置pin_memory=False
1.4 在只有cpu的电脑中加载gpu下的模型时要设置map_location='cpu'
    net = torch.load(f,map_location='cpu')
    state_dict_load = torch.load(f,map_location='cpu')
1.5 多gpu训练的模型需要特别的加载形式
    '''
    'module.linears.0.weight','module.linears.1.weight',
    'module.linears.2.weight','module.linears.3.weight'
    '''
    from collections import OrderedDict
    # 构建有序字典
    new_state_dict = OrderedDict()
    for k,v in state_dict_load.items():
        # 如果k以'module.'开头则取第七个开始的
        namekey = k[7:] if k.startswith('module.') else k
        new_state_dict[namekey] = v
     # 判断gpu是否可用

torch.cuda.is_available()
# 获取可使用的gpu数量
torch.cuda.device_count()
# 查看gpu具体配置
nvidia-sim
# 获取gpu名称
torch.cuda.get_device_name()
    # 为当前gpu设置随机种子
torch.cuda.manual_seed()
# 为所有可见可用的gpu设置随机种子
torch.cuda.manual_seed_all()
# gpu的选择
'''按顺序选2号gpu和3号gpu'''
os.environ.setdefault('CUDA_VISIBLE_DEVICES','2,3')
'''按顺序选0号、3号和2号gpu'''
os.environ.setdefault('CUDA_VISIBLE_DEVICES','0,3,2')

# 先分发(分配任务)，再并行(并行运行)
@每个gpu中的数据量为batchsize除参与分发的gpu数量
# model:需要包装分发的模型
# device_ids:可分发的gpu,默认分发到所有可见可用的gpu
# output_device:结果输出设备
torch.nn.DataParallel(model,device_ids=None,output_device=None,dim=0)  
model.to(device)