一些用到的Pytorch知识点的总结(2)

都是一些基础的函数，在这里记下当作笔记以后好查。大部分都是官方文档的翻译，贴的有地址

---

nn.Embedding.weight

torch.nn.Embedding文档
生成的Embedding的weight属性，如果不给weight赋值，Embedding类会自动初始化，符合正态分布(0, 1)
Pytorch的默认初始化分布 nn.Embedding.weight初始化分布。

import torch.nn as nn
b = nn.Embedding(2, 3)
b.weight
-------------------------------------------------------
outputs:
Parameter containing:
tensor([[-1.2576, -1.1761,  0.8217],
        [ 2.4802, -0.7803,  0.0659]], requires_grad=True)

nn.Module.register_buffer

nn.Module.register_buffer文档

向模块添加持久缓冲区

这通常用于注册一个不应该被视为模型参数的缓冲区。例如，BatchNorm的running_mean不是一个参数，但是是模型状态的一部分
默认情况下，缓冲区是持久的，并将与参数一起保存，可以通过将persistent设置为False来更改此行为。
持久缓冲区和非持久缓冲区之间的唯一区别是，后者不会成为这个模块的state_dict的一部分。

缓冲区可以使用给定名称行为属性进行访问

nn.module与nn.Sequential

torch.nn.Module文档
class torch.nn.Module

是所有神经网络模块的基类。
你的模型应该是这个类的子类。
模块还可以包括其他模块，允许将它们嵌套在树形结构中。你可以将子模块指定为常规属性

例子：

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)
        
    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

以这种方式分配的子模块将被注册，并且在调用to()等时，也将转换它们的参数。

torch.nn.Sequential文档
CLASS torch.nn.Sequential(*args)

一个sequential容器，模块将会按照它们在构造函数中传递的顺序添加到它中。
另外，也可以传入一个有序的模块字典。

为了更容易理解，这里有一个小例子:

# 使用Sequential
model = nn.Sequential(
            nn.Conv2d(1, 20, 5),
            nn.ReLU(),
            nn.Conv2d(20, 64, 5),
            nn.ReLU
        )
        
# 使用OrderedDict在Sequential
model = nn.Sequential(OrderedDict([
            ('conv1', nn.Conv2d(1, 20, 5)),
            ('relu1', nn.ReLU()),
            ('conv2', nn.Conv2d(20, 64, 5)),
            ('relu2', nn.ReLU())
            ]))

nn.Linear

nn.linear文档

CLASS torch.nn.Linear(in_features, out_features, bias=True)

对输入数据应用线性转换:y = xA^T + b
支持 TensorFloat32

示例：

 m = nn.Linear(20, 30)
 input = torch.randn(128, 20)
 output = m(input)
 print(output.size())
 # torch.Size([128, 30])

nn.Dropout

这里看原文吧
nn.Dropout文档
在训练时，使用伯努利分布的，以概率p随机地将输入张量的一些元素置为0.
每一个chennel将在前向传播中独立清零。这已被证明是一种有效的正则化技术，阻止过拟合。
此外， 在训练期间这个输出时被1/(1-p)的因子缩放。这意味着在评估期间，这模块简单计算一个独立函数

示例：

m = nn.Dropout(p=0.2)
input = torch.randn(20, 16)
output = m(input)

torch.equal与torch.eq

torch.equal(input, other) → bool

如果两个tensor大小和元素相同返回True, 否则返回False
torch.equal(torch.tensor([1, 2]), torch.tensor([1, 2]))

torch.eq

torch.eq(input, other, *, out=None) → Tensor
按照位置计算元素是否相等。
第二个参数可以是一个数字或一个张量，其形状可以与第一个参数一起传播。
return 一个boolean的tensor

示例：

torch.eq(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))
# tensor([[ True, False],
#         [False, True]])
# True

总结

小笔记