pytorch总结

2021-12-10

1. torch.utils.data

1.1 torch.utils.data.DataLoader类

是加载数据的核心，返回可迭代数据。

class torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, batch_sampler=None, num_workers=0, collate_fn=, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None)
'''
* dataset：加载的数据集
* batch_size(int,optional)：每批加载多少个样本
* shuffle(bool,optional)：默认是false，当设置为true时在每个epoch对数据打乱
** sampler (Sampler, optional): 定义从数据集中提取样本的策略,返回一个样本
* batch_sampler (Sampler, optional): like sampler, but returns a batch of indices at a time 返回一批样本. 与atch_size, shuffle, sampler和 drop_last互斥.
* num_workers (int, optional): 用于加载数据的子进程数。0表示数据将在主进程中加载。（默认：0）
* collate_fn (callable, optional): 合并样本列表以形成一个 mini-batch.  #　callable可调用对象
* pin_memory (bool, optional): 如果为 True, 数据加载器会将张量复制到 CUDA 固定内存中,然后再返回它们.
* drop_last (bool, optional): 设定为 True 如果数据集大小不能被批量大小整除的时候, 将丢掉最后一个不完整的batch,(默认：False).
* timeout (numeric, optional): 如果为正值，则为从工作人员收集批次的超时值。应始终是非负的。（默认：0）
* worker_init_fn (callable, optional): If not None, this will be called on each worker subprocess with the worker id (an int in ``[0, num_workers - 1]``) as input, after seeding and before data loading. (default: None)．
'''

是一个数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集。在训练模型时使用到此函数，用来把训练数据分成多个小组，此函数每次抛出一组数据。直至把所有的数据都抛出。做到一个数据的初始化。

'''
在神经网络中，参数默认是进行随机初始化的。
不同的初始化参数往往会导致不同的结果，当得到比较好的结果时我们通常希望这个结果是可以复现的，
在pytorch中，通过设置随机数种子也可以达到这么目的。
torch.manual_seed(1)
'''
import torch
import torch.utils.data as Data
torch.manual_seed(1)
BATCH_SIZE = 5

x = torch.linspace(1,10,10)
y = torch.linspace(10,1,10)

torch_dataset = Data.TensorDataset(x,y)#将数据存入到数据库中
loader = Data.DataLoader(
    #从dataset数据库中每次抽出batch_size个数据
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,#数据打乱
    num_workers=2,#使用两个线程
)

def show_batch():
    for epoch in range(3):
        for step,(batch_x,batch_y) in enumerate(loader):
            print('Epoch:',epoch,'|Step:',step,"|batch x:",
                  batch_x.numpy(),'|batch y:',batch_y.numpy())
if __name__ == '__main__':
    show_batch()
[In]
Epoch: 0 |Step: 0 |batch x: [5. 3. 1. 7. 9.] |batch y: [ 6.  8. 10.  4.  2.]
Epoch: 0 |Step: 1 |batch x: [ 8. 10.  2.  6.  4.] |batch y: [3. 1. 9. 5. 7.]
Epoch: 1 |Step: 0 |batch x: [5. 9. 2. 6. 1.] |batch y: [ 6.  2.  9.  5. 10.]
Epoch: 1 |Step: 1 |batch x: [ 3.  4.  7. 10.  8.] |batch y: [8. 7. 4. 1. 3.]
Epoch: 2 |Step: 0 |batch x: [6. 9. 4. 8. 7.] |batch y: [5. 2. 7. 3. 4.]
Epoch: 2 |Step: 1 |batch x: [10.  3.  2.  1.  5.] |batch y: [ 1.  8.  9. 10.  6.]

1.2 torch.utils.data.Dataset类

创建数据集，有_getitem_(self,index)函数来根据索引序号来获取图片和标签，有len(self)函数来获取数据集的长度。其他的数据集类必须是其子类，要继承它的特性。

我们如果要自定义自己数据读取的方法，就需要继承torch.utils.data.Dataset，并将其封装到DataLoader中。torch.utils.data.Dataset表示该数据集，继承该类可以重载其中的方法，实现多种数据读取及数据预处理的方式。TensorDataset（）方法可以将tensor数据装载进入称为dataset

from torch.utils.data import DataLoader,Dataset
import torch

class TensorDataset(Dataset):
    def __init__(self,data_tensor,target_tensor):
        self.data_tensor = data_tensor
        self.target_tensor = target_tensor

    def __getitem__(self, index):
        return self.data_tensor[index],self.target_tensor[index]

    def __len__(self):
        return self.data_tensor.size(0)
data_tensor = torch.randn(4,3)
target_tensor = torch.rand(4)
# print(target_tensor)
#将数据封装成dataset
tensor_dataset = TensorDataset(data_tensor,target_tensor)
print(len(tensor_dataset))
#可使用索引调用数据
print('tensor_dataset[0]：',tensor_dataset[0])
print('len os tensor_dataset：',len(tensor_dataset))

得到的dataset的数据类型是一个元组，元组的每一个对象都是一个tensor数据类型。

1.3 torch.utils.data.sampler

对于可迭代样式的数据集，数据加载顺序完全由用户定义的可迭代样式控制。这样可以更轻松地实现块读取和动态批处理大小(可以每次生成一个批处理的样本)。

pytorch中提供了以下的集中不同方式的数据采样：

sequential sampler（顺序采样）
random sampler（随机采样）
subset random sampler（子随机采样）
weighted random sampler（加权随机采样）

Squential Sampler

from torch.utils.data import DataLoader,Dataset,Sampler
import torch

class SequentialSampler(Sampler):
    r"""Samples elements sequentially, always in the same order.
    Arguments:
        data_source (Dataset): dataset to sample from
    """
    def __init__(self,data_source):
        self.data_source = data_source
    def __iter__(self):
        return iter(range(len(self.data_source)))
    def __len__(self):
        return len(self.data_source)
data = list([17,22,3,41,8])
seq_sampler = SequentialSampler(data_source=data)
for index in seq_sampler:
    print("index: {},data: {}".format(str(index),str(data[index])))

[output]:
index: 0,data: 17
index: 1,data: 22
index: 2,data: 3
index: 3,data: 41
index: 4,data: 8

random sampler

class RandomSampler(Sampler):

     r"""Samples elements randomly. If without replacement, then sample from a shuffled dataset.
    If with replacement, then user can specify :attr:`num_samples` to draw.
    Arguments:
        data_source (Dataset): dataset to sample from
        replacement (bool): samples are drawn with replacement if ``True``, default=``False``
        num_samples (int): number of samples to draw, default=`len(dataset)`. This argument
            is supposed to be specified only when `replacement` is ``True``.
    """

     def __init__(self,data_source,replacement=False,num_samples=None):
         self.data_source = data_source
         #这个参数控制的是否重复采样
         self.replacement = replacement
         self._num_samples = num_samples
     ''' @property是python的一种装饰器
     是用来修饰方法的，可以使用它来创建只读属性
    可以与所定义的属性配合使用，这样可以防止属性被修改
     '''
     @property
     def num_samples(self):
         if(self._num_samples is None):
             return len(self.data_source)
         return self._num_samples
     #返回数据集的长度
     def __len__(self):
         return self.num_samples

     def __iter__(self):
         n = len(self.data_source)
         if(self.replacement):#生成的随机数可能是重复的
             return iter(torch.randint(high=n,size=(self.num_samples,),dtype=torch.int64).tolist())
         return iter(torch.randperm(n).tolist())
data = list([17,22,3,41,8])
ran_sampler = RandomSampler(data_source=data)
for index in ran_sampler:
    print("index: {},data: {}".format(str(index),str(data[index])))
index: 0,data: 17
index: 4,data: 8
index: 3,data: 41
index: 2,data: 3
index: 1,data: 22

subset random sampler

class SubsetRandomSampler(Sampler):
    r"""Samples elements randomly from a given list of indices, without replacement.
    Arguments:
        indices (sequence): a sequence of indices
    """
    def __init__(self,indices):
        self.indices = indices#数据集的切片，划分训练集和测试集
    def __iter__(self):
        return (self.indices[i] for i in torch.randperm(len(self.indices)))
    def __len__(self):
        return len(self.indices)
if __name__ == '__main__':
     data = list([17,22,3,41,8])
sub_sampler = SubsetRandomSampler(indices=data[0:2])
for index in sub_sampler:
    print("index: {},data: {}".format(str(index),str(data[index])))

weighted random sampler

class WeightedRandomSampler(Sampler):
    r"""Samples elements from ``[0,..,len(weights)-1]`` with given probabilities (weights)."""
    def __init__(self, weights, num_samples, replacement=True):
         # ...省略类型检查
         # weights用于确定生成索引的权重
        self.weights = torch.as_tensor(weights, dtype=torch.double)
        self.num_samples = num_samples
        # 用于控制是否对数据进行有放回采样
        self.replacement = replacement
    def __iter__(self):
        # 按照加权返回随机索引值
        return iter(torch.multinomial(self.weights, self.num_samples, self.replacement).tolist())
if __name__ == '__main__':
    weights = torch.Tensor([0, 10, 1.1, 1.1, 1.1, 1.1, 1.1])
    wei_sampler = WeightedRandomSampler(weights=weights, num_samples=6, replacement=True)

2. sklearn.model_selection

2.1 train_test_split

1	train_test_split(*array,test_size=0.25,train_size=None,random_state=None,shuffle=True,stratify=None)

返回切分的数据集train/test，传参是：

array：切分的数据源
test_size和train_size：互补和为1的一对值
shuffle：是否对数据切分之前进行乱序
stratify：是否分层抽样切分数据

2.2 cross_validate

1 2	cross_validate(estimator,X,y=None,groups=None,scoring=None,cv=None,n_jobs=1, verbose=0,fit_params=None,pre_dispatch='2*n_jobs',return_train_score='warn')

返回train/test数据集上的每折得分

estimator：学习器
X：特征列数据 y：标签列（无监督学习可以无此参数） groups：切分train/test数据集后的样本所在集合标号 scoring：在test数据集上的评估准则（以list/dict形式给出） cv：交叉验证的折数，default=3，也可以是其余int数据，或者cv generator n_jobs：计算执行时占用CPU个数，设置n_jobs=-1是利用全部CPU verbose：设置评估模型的相关打印信息输出详细程度 fit_params：参数字典 pre_dispatch：设置并行任务数（保护内存） return_train_score：返回train数据集上的评估得分

2.3 learning_curve

1
2
3

GridSearchCV(estimator,X,y,groups=None，train_sizes=array([0.1,0.33,0.55,0.78,1.]),cv=None,
scoring=None,exploit_incremental_learning=False,n_jobs=1,
pre_dispatch='all',verbose=0,shuffle=False,random_state=None)

根据设定的不同train数据集大小，依次获得交叉熵验证的train/test数据集上的得分

estimator：学习器 X：特征列数据 y：标签列 groups：切分train/test数据集后的样本所在集合标号 train_sizes：设置训练集数据的变化取值范围 cv：交叉验证的折数，default=3，也可以是其余int数据，或者cv generator scoring：在test数据集上的评估准则（以list/dict形式给出） n_jobs：计算执行时占用CPU个数，设置n_jobs=-1是利用全部CPU pre_dispatch：设置并行任务数（保护内存） verbose：设置评估模型的相关打印信息输出详细程度 shuffle：对数据切分前是否洗牌 random_state：随机种子 exploit_incremental_learning：增量学习

3. torch.nn.utils.rnn

3.1 pack_padded_sequence和pad_packed_sequence

这两个函数主要是为了处理变长序列的padding，一般进行深度学习训练的时候都会分为batch个训练数据一起进行计算，这样会遇到多个训练样例长度不一样的情况，这样就很容易的想到padding，将短的句子padding位跟最长的句子一样。

pack相当于压缩填充过的变长序列，因为填充的时候会有冗余所以要压紧。有了pad的操作之后，padding出现了很多无用的符号，这样得到的句子特征会有误差。pack之后，原来填充PAD的地方就被删除了。输入的形状是\((T \times B \times *)\)，T是最长序列的长度，B是batch_size，*代表任意维度。如果batch_first=True的话，那么相应的input size就是\((B \times T \times *)\)。Variable中保存的序列，应该按序列长度的长短排序，长的在前，短的在后。即input[ : , 0]代表的是最长的序列，input[ : , B - 1]保存的是最短的序列。

1 2	embed_input_x_packed = pack_padded_sequence(embed_input_x, sentence_lens, batch_first=True) encoder_outputs_packed, (h_last, c_last) = self.lstm(embed_input_x_packed)

参数：

input(Variable)：变长序列，被填充后的batch

lengths(list[int])：variable中每个序列的长度

batch_first(bool,optional)：如果是True，input的形状应该是\(B \times T \times size\)

返回值：一个PackedSequence对象。