pytorch文档阅读笔记-03-torch02（随机抽样、序列化、并行））

东阳的学习记录，坚持就是胜利！

随机抽样（Random sampling）

torch.manual_seed

torch.manual_seed(seed)

设定生成随机数的种子，并返回一个 torch._C.Generator 对象.(固定随机数)

**注意：**在每次使用随机函数之前，都要设置一次seed。

>>> torch.manual_seed(seed)
<torch._C.Generator object at 0x7f304a189d30>
>>> torch.rand(36)
tensor([0.4869, 0.1052, 0.5883, 0.1161, 0.4949, 0.2824, 0.5899, 0.8105, 0.2512,
        0.6307, 0.5403, 0.8033, 0.7781, 0.4966, 0.8888, 0.5570, 0.7127, 0.0339,
        0.1151, 0.8780, 0.0671, 0.5173, 0.8126, 0.3861, 0.4992, 0.5970, 0.0498,
        0.7595, 0.3198, 0.4828, 0.7016, 0.9966, 0.5778, 0.1164, 0.7253, 0.1315])
>>> torch.manual_seed(seed)
<torch._C.Generator object at 0x7f304a189d30>
>>> torch.rand(36)
tensor([0.4869, 0.1052, 0.5883, 0.1161, 0.4949, 0.2824, 0.5899, 0.8105, 0.2512,
        0.6307, 0.5403, 0.8033, 0.7781, 0.4966, 0.8888, 0.5570, 0.7127, 0.0339,
        0.1151, 0.8780, 0.0671, 0.5173, 0.8126, 0.3861, 0.4992, 0.5970, 0.0498,
        0.7595, 0.3198, 0.4828, 0.7016, 0.9966, 0.5778, 0.1164, 0.7253, 0.1315])

torch.initial_seed

返回生成随机数的原始种子值（python long）
下面的例子接上一个例子：

>>> torch.initial_seed()
2020

torch.get_rng_state

返回随机生成器状态(ByteTensor)：不知道有什么用。

torch.set_rng_state

同上，不知道有什么用

torch.default_generator

同上，不知道什么用

torch.bernoulli

torch.bernoulli(input, out=None) → Tensor

从伯努利分布中抽取二元随机数(0 或者 1)。

输入张量须包含用于抽取上述二元随机值的概率。 因此，输入中的所有值都必须在［0,1］区间，即 0<=inputi<=1

>>> a = torch.Tensor(3, 3).uniform_(0, 1) # generate a uniform random matrix with range [0, 1]
>>> a

 0.7544  0.8140  0.9842
 0.5282  0.0595  0.6445
 0.1925  0.9553  0.9732
[torch.FloatTensor of size 3x3]

>>> torch.bernoulli(a)

 1  1  1
 0  0  1
 0  1  1
[torch.FloatTensor of size 3x3]

torch.multinomial

为什么我和官网给出例子的运行结果不一样呢？？

torch.multinomial(input, num_samples,replacement=False, out=None) → LongTensor

返回一个张量，每行包含从input相应行中定义的多项分布中抽取的num_samples个样本。

参数：

• input (Tensor) – 包含概率值的张量
• num_samples (int) – 抽取的样本数
• replacement (bool, optional) – 布尔值，决定是否能重复抽取
• out (Tensor, optional) – 结果张量

>>> weights = torch.Tensor([0, 10, 3, 0]) # create a Tensor of weights
>>> torch.multinomial(weights, 4)

 1
 2
 0
 0
[torch.LongTensor of size 4]

>>> torch.multinomial(weights, 4, replacement=True)

 1
 2
 1
 2
[torch.LongTensor of size 4]

torch.normal()

1

torch.normal(means, std, out=None)

返回一个张量，包含从给定参数means,std的离散正态分布中抽取随机数。 均值means是一个张量，包含每个输出元素相关的正态分布的均值。 std是一个张量，包含每个输出元素相关的正态分布的标准差。 均值和标准差的形状不须匹配，但每个张量的元素个数须相同。

参数:

• means (Tensor) – 均值
• std (Tensor) – 标准差
• out (Tensor) – 可选的输出张量
  mean需要是浮点数才不会报错, 而且使用means会报错（注意一下）

>>> torch.normal(mean=torch.arange(1., 11.), std=torch.arange(1, 0, -0.1))
tensor([2.5312, 2.4500, 3.0892, 4.3596, 5.1613, 5.9750, 7.5307, 7.8629, 9.2862,
        9.9313])

2

torch.normal(mean=0.0, std, out=None) → Tensor

>>> torch.normal(mean=0.5, std=torch.arange(1., 6.))
tensor([ 1.1143,  1.4433, -1.4141, -4.4159, -1.2729])
>>> torch.arange(1., 6.)
tensor([1., 2., 3., 4., 5.])

3

torch.normal(mean, std, size, *, out=None) → Tensor

>>> torch.normal(2, 3, size=(1, 4))
tensor([[-1.3987, -1.9544,  3.6048,  0.7909]])

序列化

torch.saves

torch.save(obj, f, pickle_module=, pickle_protocol=2)

将tensor对象保存到硬盘上。

参数：
obj – 保存对象
f － 类文件对象 (返回文件描述符)或一个保存文件名的字符串
pickle_module – 用于pickling元数据和对象的模块
pickle_protocol – 指定pickle protocal 可以覆盖默认参数

>>> x
tensor([ 0.6070,  0.5762, -1.0644,  0.7500, -0.2159, -0.6689,  0.2730,  1.2573,
        -1.7232,  0.4999,  0.3718, -0.1023, -1.4153, -0.9422,  0.6387, -1.2587,
        -0.0926,  0.3074, -0.3839,  0.0710, -0.6843, -0.2352,  1.3049, -1.2827,
        -0.4027,  1.9044, -1.5264,  0.7107, -1.5048,  0.9602,  0.5114,  1.7648,
        -1.0033, -1.5787, -0.0919, -0.1104])
>>> torch.save(x, 'x.tensor')

torch.load

torch.load(f, map_location=None, pickle_module=)

从磁盘文件中读取一个通过torch.save()保存的对象。 torch.load() 可通过参数map_location 动态地进行内存重映射，使其能从不动设备中读取文件。一般调用时，需两个参数: storage 和 location tag. 返回不同地址中的storage，或着返回None (此时地址可以通过默认方法进行解析). 如果这个参数是字典的话，意味着其是从文件的地址标记到当前系统的地址标记的映射。 默认情况下， location tags中 "cpu"对应host tensors，‘cuda:device_id’ (e.g. ‘cuda:2’) 对应cuda tensors。 用户可以通过register_package进行扩展，使用自己定义的标记和反序列化方法。

简单来说就是可以使用该参数指定load的设备
有四种不同情况，并做不同处理。

例子：

# 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={'cuda:1':'cuda:0'})

# 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)

并行（暂无深究）

1. get_num_threads： 获得用于并行化CPU操作的OpenMP线程数（intraop parallelism）
2. torch.set_num_threads：设定用于并行化CPU操作的OpenMP线程数（intraop parallelism）
3. get_num_interop_threads： （ interop parallelism ）
4. set_num_interop_threads：（interop parallelism）