ReLU

1

nn.ReLu(inplace = True)

参数inplace=True:

inplace为True，将会改变输入的数据，否则不会改变原输入，只会产生新的输出

inplace：can optionally do the operation in-place. Default: False

注：产生的计算结果不会有影响。利用in-place计算可以节省内（显）存，同时还可以省去反复申请和释放内存的时间。但是会对原变量覆盖，只要不带来错误就用。　

Conv2d

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


torch.nn.Conv2d(    
    in_channels,
    out_channels,
    kernel_size,
    stride = 1,
    padding = 0,
    dilation = 1,
    groups = 1,
    bias = True,
    padding_mode = 'zeros'
    )

in_channels ：输入通道数目

out_channels ：输出通道数目

kernel_size ：卷积核大小，如果输入是一个值，比如 3 ，那么卷积核大小就是 3 × 3 ，还可以输入tuple类型数据，比如： ( 3 , 5 )

stride ：步长大小，跟上面卷积核参数一样，如果输入是一个值，比如 2 ，步长就是 2 × 2 ，还可以输入元组 ( 2 , 1 )，表示卷积核每次向右移动 1 个步长，向下移动 2 个步长。默认为1。

padding ：填充，参数表示在周围补0的情况。补0的方向为上、下、左、右四个方向。如果是输入是单个值，比如1，就是在上下左右四个方向补一圈0。如果输入是元组比如 (2,1) ，表示在上下两个方向各补两行0，在左右两个方向各补一列0。

dilation ：进行扩展卷积需要的参数。默认为1，即普通卷积。

groups ：进行分组卷积需要的参数。（有需要自行深入了解）

bias ：偏置，布尔类型，默认为 True ，即增加一个学习的偏置项。一般设置为False，设置为True的话可以增加模型的泛化能力

padding_mode ：填充的模式，默认是 zero ，一般都默认设置为0。还可以选择 reflect 、 replicate 、 circular 。

cat

注意是tensors，是一个序列，所以必须得加括号。　

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 按维数 0 拼接（竖着拼）
C = torch.cat( (A,B),0 )
# 按维数 1 拼接（横着拼）
C = torch.cat( (A,B),1 )

A=torch.ones(2,3)
print(f'Matrix A is:\n{A}')
B = 2*A
print(f'Matrix B is:\n{B}')
C = torch.cat((A,B),0)
print(f'Concatenate matrix A and B in columns:\n{C}')
D = torch.cat((A,B),1)
print(f'Concatenate matrix A and B in rows:\n{D}')

transpose、reshape、view

reshape

reshape()和view() 功能几乎一样，但是 view() 只能操作 tensor，reshape() 可以操作 tensor 和 ndarray。
reshape()不改变tensor的内容，要改变tensor的内容需要重新赋值。A = A.reshape(2,3)
括号内是int元组

view() 只能用在 contiguous 的 variable 上。如果在 view 之前用了 transpose, permute 等，需要用 contiguous() 来返回一个 contiguous copy。 view() 操作后的 tensor 和原 tensor 共享存储。　

1
2
3
4
5
6


"Args:
    shape (tuple of ints or int...): the desired shape"
x = np.array([1, 2, 3, 4, 5, 6])  # 一个大小为 6 的一维 numpy 数组
y = torch.Tensor([1, 2, 3, 4, 5, 6])  # 一个大小为 6 的一阶张量
print(x.reshape(2, 3))  # 重组 x 为结构为 (2， 3) 的数组
print(y.reshape(2, 3))  # 重组 y 为结构为 (2， 3) 的张量

view()

对于一个 1 阶张量 x，进行view(h, w) 操作就是按照索引先后顺序每次从 x 中取出 w 个元素作为作为一行数据，共取 h 次，构成一个 (h, w) 结构的 2 阶张量，具体见示例。【补充】h是行，w是列。

1
2


x = torch.Tensor([1, 2, 3, 4, 5, 6, 7, 8])  # 一个含有 8 个元素的 1 阶张量
print(x.view(4, 2))  # 返回一个 (4, 2) 结构的 2 阶张量

对于一个 1 阶张量 x，进行 view(c, h, w) 操作就是按照索引先后顺序每次从 x 中取出 h*w 个元素，对这 h*w 个元素按照 1 阶张量转 2 阶数张量的方法转为一个 (h, w) 结构的 2 阶张量，共取 c 次，构成一个 (c, h, w) 结构的 3 阶张量，具体见示例。

1
2


x = torch.Tensor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])  # 一个含有 12 个元素的 1 阶张量
print(x.view(3, 2, 2))  # 返回一个 (3, 2, 2) 结构的 3 阶张量

transpose()

对于一个 2 阶张量，结构为 (h, w)，对应 transpose() 函数中的参数是 (0, 1) 两个索引，进行 transpose(0, 1) 操作就是在交换 h, w 两个维度，得到的结果是转置后的矩阵，具体代码示例见下。

1
2
3
4
5
6
7


x = torch.Tensor([[1, 2],
                  [3, 4],
                  [5, 6]])  # 一个结构为 (3, 2) 的 2 阶张量
print(f'x.size() = {x.size()}')  # 返回张量 x 的结构
y = x.transpose(0, 1)  # 交换 h, w 两个维度
print(f'y.size() = {y.size()}')  # 返回张量 y 的结构
print(y)  # 打印交换维度后的张量 y，结构为 (2, 3)

name

一般来说，我们在写完自定义的模块之后（例如Module.py），都会写一个测试代码，检验各个功能模块是否成功运行。假设我们有Module.py文件，

1

print("Output from Module.py")

单独运行此模块文件，得到相应的结果。在同目录下创建一个文件train.py。

1
2


import Module
print("train.py")

运行train.py得到：

1
2


Output from Module.py
train.py

可以看到，Python解释器将模块（Module.py）中的测试代码也一块儿运行了，但我们只想运行train.py模块，所以这并不是我们想要的结果。因此，要让 Python 解释器知道，当前要运行的程度代码，是模块文件本身，还是导入模块的其它程序。为了实现这一点，就需要使用 Python 内置的系统变量 name，它用于标识所在模块的模块名。例如，在train.py 程序文件中，添加如下代码：

1
2


print(f'__name__ is:{__name__}')
print(f'Module.__name__ is:{Module.__name__}')

所以，我们通常使用if __name__ == "__main__": 确保只有该模块单独运行时，才可以进入此判断语法，执行其中的测试代码；

反之，如果只是作为模块导入到其他程序文件中，则此表达式将不成立，运行其它程序时，也就不会执行该判断语句中的测试代码。　

ReLU#

Conv2d#

cat#

transpose、reshape、view#

reshape#

view()#

transpose()#

name#

参考资料#