TORCH02-02:Torch常见机器学习函数

Torch的核心是求导,求导依赖运算函数的定义,函数运算在Torch中也是重点之一,有的函数使用Function接口规范,会提升求导的效率;本主题主要梳理Torch与机器学习有关的函数运算;
  1. Tensor中实现的函数运算
  2. torch.nn.functional中封装的各类函数


说明:其中的激活函数对机器学习的训练非常重要


张量运算函数

  • 下面三个函数有两种使用方式:
    • torch模块的全局函数
    • Tensor类中的成员函数

mm与addmm运算

mm函数说明

  • mm是矩阵与矩阵的乘法(内积)封装,这个函数只多矩阵运算,所以其源代码会检测输入向量的维度,维度必须是2维的。
    torch.mm(input, mat2, out=None) → Tensor
  • 参数说明:
    • input:运算矩阵
    • mat2:第二个矩阵

addmm函数说明

  • 计算公式是
    addmm(beta=1, input, alpha=1, mat1, mat2, out=None) -> Tensor
  • 参数说明:
    • beta:对应上面公式中的
    • input:对应上面公式中的
    • alpha:对应上面公式中的
    • mat1:对应上面公式中的
    • mat2:对应上面公式中的

使用例子

  1. mm函数的使用例子
import torch

m_input = torch.Tensor(
    [
        [1, 2],
        [3, 4],
        [5, 6]
    ]
)

mat2 = torch.Tensor(
    [
        [1, 2, 3],
        [4, 5, 6]
    ]
)
# vec2 = torch.Tensor(
#     [1,2]
# )

out = torch.mm(m_input, mat2)
print(out)
# out = torch.mm(m_input, vec2)
# print(out)
tensor([[ 9., 12., 15.],
        [19., 26., 33.],
        [29., 40., 51.]])
  1. addmm函数的使用例子
import torch

m_input = torch.Tensor(
    [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
)

mat1 = torch.Tensor(
    [
        [1, 2],
        [3, 4],
        [5, 6]
    ]
)

mat2 = torch.Tensor(
    [
        [1, 2, 3],
        [4, 5, 6]
    ]
)

out = torch.addmm(input=m_input, mat1=mat1, mat2=mat2, beta=1, alpha=1)
print(out)
tensor([[10., 14., 18.],
        [23., 31., 39.],
        [36., 48., 60.]])

mv与addmv运算

  • mv/addmv与mm/addmm函数类似,不过是矩阵与向量间的运算公式

    • mv是矩阵与向量的内积
    • addmv的计算公式是:
  • 注意:

    • 矩阵与向量的运算,最后输出的是向量

mv函数说明

    torch.mv(input, vec, out=None) -> Tensor

addmv函数说明

    torch.addmv(beta=1, input, alpha=1, mat, vec, out=None) -> Tensor

使用例子

  1. mv函数使用例子
import torch

m_input = torch.Tensor(
    [
        [1, 2, 3],
        [4, 5, 6]
    ]
)

vec = torch.Tensor(
    [1, 2, 3]
)

out = torch.mv(input=m_input, vec=vec)
print(out)   # 输出的是向量
tensor([14., 32.])
  1. addmv使用例子
import torch

m_input = torch.Tensor(
    [1, 2, 3]
)

mat = torch.Tensor(
    [
        [1, 2],
        [3, 4],
        [5, 6]
    ]
)

vec = torch.Tensor(
    [1, 2]
)

out = torch.addmv(input=m_input, mat=mat, vec=vec, beta=1, alpha=1)
print(out)    # 输出的是向量
tensor([ 6., 13., 20.])

addbmm函数

  • addbmm函数批量操作,其封装的计算公式如下:

    • 其中的b表示batch维度,也就是batch1与batch2是3维矩阵,第一维表示批量大小。

  • 这个函数用来图像运算比较方便,因为图像包含颜色深度。

addbmm函数说明

    torch.addbmm(beta=1, input, alpha=1, batch1, batch2, out=None) -> Tensor

使用例子

import torch

M = torch.randn(3, 5)
batch1 = torch.randn(10, 3, 4)    # 10表示批次
batch2 = torch.randn(10, 4, 5)   # 10表示批次

out = torch.addbmm(M, batch1, batch2)
print(out)
tensor([[  3.3873,  -1.3027,   2.8728,  -0.7336,   7.9643],
        [ -3.1864,  -0.2114,  -2.7413,  -5.1329,   0.3058],
        [ -9.4950,  -2.7834, -13.0682,  -6.0314,   3.7112]])
import torch

m_input = torch.Tensor(
    [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
)

mat1 = torch.Tensor(
    [
        [
            [1, 2],
            [3, 4],
            [5, 6]
        ],   # batch =1
    ]
)

mat2 = torch.Tensor(
    [
        [
            [1, 2, 3],
            [4, 5, 6]
        ], # batch =1
    ]
)

out = torch.addbmm(input=m_input, batch1=mat1, batch2=mat2, beta=1, alpha=1)    # 要求batch必须是三维
print(out)
tensor([[10., 14., 18.],
        [23., 31., 39.],
        [36., 48., 60.]])

模块torch.nn函数

卷积运算函数

  • 主要使用2D卷积做图像处理,所以下面只讲解下2D卷积。

函数说明

    torch.nn.functional.conv2d(
        input,             # 被处理2D矩阵
        weight,           # 2D卷积核(共享权重)
        bias=None,     # 2D偏置项
        stride=1,         # 卷积运算的步长,可以是一个整数(表示高宽使用相同的步长)或者元组(表示高宽使用不同的步长)。
        padding=0,     # 补边长度(这个需要手工计算传入) 
        dilation=1,       # dilation卷积核的间隔,可以一个整数(表示两个方向一样),或者元组(表示两个方向)
        groups=1) → Tensor
  • 核心参数格式说明:
    • input:四维张量Tensor,维度说明(批量数,深度,高度,宽度)
    • weight:四维张量Tensor,维度说明(输出数, 深度,高度,宽度)
      • 如果指定groups,则深度分成组计算,则是个维度为(输出数, 深度/groups,高度,宽度)
    • bias:卷积运算的偏置项,一维张量,维度为(输出数)

使用例子

  • 例子中,使用图像来说明
%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
num_imgs = org_imgs.transpose(2, 0, 1)    # 变换下维度(根据卷积函数的要求,把深度变成第一维)

# 批量(图像数量)1,深度3,高300,宽300
input = torch.from_numpy(num_imgs).view(
    1,     # 批量
    num_imgs.shape[0],    # 深度
    num_imgs.shape[1],    # 高度
    num_imgs.shape[2]).double()    # 宽度

# 定义卷积核
kernel = torch.DoubleTensor(
     [
         [
             [-1, -1,  0],
             [-1,  0,  1],
             [ 0,   1,  1]
         ],
        [
             [-1, -1,  0],
             [-1,  0,  1],
             [ 0,   1,  1]
         ],
        [
             [-1, -1,  0],
             [-1,  0,  1],
             [ 0,   1,  1]
         ]
     ]
 ).view(1, 3, 3 ,3)   # 输出一副图像,深度是3,高度是3,宽度是3
# print(input.shape)
# print(kernel.shape)
# 注意:卷积核是3大小,padding就是1,卷积核大小是5,则padding就是2,如果padding=0,则输出图像高宽-2
out_image = torch.conv2d(input, kernel, padding=1, bias=torch.DoubleTensor([0]))
# print(out_image)

ax1 = plt.subplot(121)
# ax1.imshow(out_image.numpy()[0][0])    # 图像深度是1,表示灰度图
ax1.imshow(out_image.numpy()[0][0], cmap='gray')
ax2 = plt.subplot(122)
ax2.imshow(org_imgs, cmap='gray')    # 图像深度是3,表示彩色图像
# print( out_image.numpy()[0][0].shape)


卷积运算

池化运算函数

  • 池化运算主要是降维,这是用于卷积神经网络的运算。
  • 池化运算一般有两种方式:
    • 平均池化
    • 最大池化
  • 池化的核的大小决定了降维的多少:
    • 2 * 2 的池化核:输出是输入的一半。

函数说明

  1. 平均池化函数
    torch.nn.functional.avg_pool2d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None) → Tensor
  • 重要参数说明:
    • input:(minibatch,in_channels,iH,iW)与卷积的输入是一致的;
    • kernel_size:池化核大小(不需要数据):使用整数或者元组;
    • padding:补边大小(补边用于池化的cell够用);
    • count_include_pad : 计算平均的时候,是否考虑padding的0;
    • ceil_mode:当计算输出形状的时候,采用取最大(ceil)还是最小(floor);
  1. 最大池化函数
    torch.nn.functional.max_pool2d(*args, **kwargs)
  • 说明:
    • 与平均池化一样,差异就是运算方式不同:
      • 平均池化:取平均数作为输出
      • 最大池化:取最大值作为输出

使用例子

%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
num_imgs = org_imgs.transpose(2, 0, 1)    # 变换下维度(根据卷积函数的要求,把深度变成第一维)

# 批量(图像数量)1,深度3,高300,宽300
input = torch.from_numpy(num_imgs).view(
    1,     # 批量
    num_imgs.shape[0],    # 深度
    num_imgs.shape[1],    # 高度
    num_imgs.shape[2]).double()    # 宽度

out = torch.nn.functional.avg_pool2d(input=input, kernel_size=5)
# print(out.shape)

out_image = out[0].byte().numpy()
out_image = out_image.transpose([1, 2, 0])
# out_image[out_image>=255] =255
# out_image[out_image<=0] =0
ax1 = plt.subplot(121, title="平均池化后图像")
ax1.imshow(out_image)

ax2 = plt.subplot(122, title="原始图像")
ax2.imshow(org_imgs)    # 图像深度是3,表示彩色图像

平均池化处理
%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
num_imgs = org_imgs.transpose(2, 0, 1)    # 变换下维度(根据卷积函数的要求,把深度变成第一维)

# 批量(图像数量)1,深度3,高300,宽300
input = torch.from_numpy(num_imgs).view(
    1,     # 批量
    num_imgs.shape[0],    # 深度
    num_imgs.shape[1],    # 高度
    num_imgs.shape[2]).double()    # 宽度

out = torch.nn.functional.max_pool2d(input=input, kernel_size=5)   # 调整池化核
# print(out.shape)

out_image = out[0].byte().numpy()
out_image = out_image.transpose([1, 2, 0])
# out_image[out_image>=255] =255
# out_image[out_image<=0] =0
ax1 = plt.subplot(121, title="最大池化后图像")
ax1.imshow(out_image)

ax2 = plt.subplot(122, title="原始图像")
ax2.imshow(org_imgs)    # 图像深度是3,表示彩色图像

最大池化运算

dropout函数

  • dropout函数有多个:
    • dropout:随机屏蔽训练元素;
    • alpha_dropout:采用伯努利分布随机屏蔽训练元素,同时还做标准化处理;
    • dropout2d:对2D的数据进行随机屏蔽;
    • dropout3d:对3D的数据进行随机屏蔽;

函数说明

  1. dropput函数
    torch.nn.functional.dropout(input, p=0.5, training=True, inplace=False)
  • 参数说明:
    • p表示被屏蔽的数据(屏蔽数据就是数据置零)
  1. alpha_dropout函数
    torch.nn.functional.alpha_dropout(input, p=0.5, training=False, inplace=False)
  1. dropout2d函数
    torch.nn.functional.dropout2d(input, p=0.5, training=True, inplace=False)
  • 参数说明:
    • input:格式按照上面conv2d与avg_pool2d一样使用;
  1. dropout3d函数
    torch.nn.functional.dropout3d(input, p=0.5, training=True, inplace=False)

使用例子

  1. dropout的例子
    • 从下面例子从可以知道,dropout后,还是保持均值不变(这个特性在选在不同dropout函数的时候,需要考虑)
%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
num_imgs = org_imgs.transpose(2, 0, 1)    # 变换下维度(根据卷积函数的要求,把深度变成第一维)

# 批量(图像数量)1,深度3,高300,宽300
input = torch.from_numpy(num_imgs).view(
    1,     # 批量
    num_imgs.shape[0],    # 深度
    num_imgs.shape[1],    # 高度
    num_imgs.shape[2]).double()    # 宽度
print(input.mean(), input.var())
out = torch.nn.functional.dropout(input=input, p=0.1, training=True)   # 调整池化核
print(out.mean(), out.var())

out_image = out[0].byte().numpy()
out_image = out_image.transpose([1, 2, 0])
# print(out_image)
ax1 = plt.subplot(121, title="dropout后的图像")
ax1.imshow(out_image, cmap="gray")

ax2 = plt.subplot(122, title="原始图像")
ax2.imshow(org_imgs, cmap="gray")    # 图像深度是3,表示彩色图像
tensor(192.1158, dtype=torch.float64) tensor(8295.0039, dtype=torch.float64)
tensor(192.1322, dtype=torch.float64) tensor(13311.1657, dtype=torch.float64)






dropout运算
  1. alpha_dropout例子

    • alpha_dropout函数保持方差不变
%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
num_imgs = org_imgs.transpose(2, 0, 1)    # 变换下维度(根据卷积函数的要求,把深度变成第一维)

# 批量(图像数量)1,深度3,高300,宽300
input = torch.from_numpy(num_imgs).view(
    1,     # 批量
    num_imgs.shape[0],    # 深度
    num_imgs.shape[1],    # 高度
    num_imgs.shape[2]).double()    # 宽度
print(input.mean(), input.var())
out = torch.nn.functional.alpha_dropout(input=input, p=0.1, training=True)   # 调整池化核
print(out.mean(), out.var())

out_image = out[0].byte().numpy()
out_image = out_image.transpose([1, 2, 0])
# print(out_image)
ax1 = plt.subplot(121, title="dropout后的图像")
ax1.imshow(out_image, cmap="gray")

ax2 = plt.subplot(122, title="原始图像")
ax2.imshow(org_imgs, cmap="gray")    # 图像深度是3,表示彩色图像
tensor(192.1158, dtype=torch.float64) tensor(8295.0039, dtype=torch.float64)
tensor(159.2412, dtype=torch.float64) tensor(9212.0347, dtype=torch.float64)






alhpa-dropout运算
  1. dropout2d例子
    • dropout2d是作用在整个通道上。
%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
num_imgs = org_imgs.transpose(2, 0, 1)    # 变换下维度(根据卷积函数的要求,把深度变成第一维)

# 批量(图像数量)1,深度3,高300,宽300
input = torch.from_numpy(num_imgs).view(
    1,     # 批量
    num_imgs.shape[0],    # 深度
    num_imgs.shape[1],    # 高度
    num_imgs.shape[2]).double()    # 宽度
print(input.mean(), input.var())
out = torch.nn.functional.dropout2d(input=input, p=0.5, training=True)   # 调整池化核
print(out.mean(), out.var())

out_image = out[0].byte().numpy()
out_image = out_image.transpose([1, 2, 0])
# print(out_image)
ax1 = plt.subplot(121, title="dropout后的图像")
ax1.imshow(out_image)

ax2 = plt.subplot(122, title="原始图像")
ax2.imshow(org_imgs,)    # 图像深度是3,表示彩色图像
tensor(192.1158, dtype=torch.float64) tensor(8295.0039, dtype=torch.float64)
tensor(384.2315, dtype=torch.float64) tensor(33180.0157, dtype=torch.float64)






dropout2d运算

dropout与dropout2d的区别

  • alpha_dropout与dropout/dropout2d区别在于标准化,但是dropout与dropout2d的在于dropout的方式。

    • dropout是对所有元素随机;
    • dropout2d是像素(3个通道要么全部置零,要么保持原状)随机;
  • 下面是一个例子说明:

  1. dropout函数
%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
input = torch.from_numpy(org_imgs).double()

out = torch.nn.functional.dropout(input=input, p=0.5, training=True)   # 只对浮点数运算
# -----------------
ax1 = plt.subplot(121, title="原始图像")
ax1.imshow(org_imgs)    # 图像深度是3,表示彩色图像
ax2 = plt.subplot(122, title="dropout后的图像")
ax2.imshow(out.byte().numpy())



dropout与dropout2d的区别在于:dropout是通道
  1. dropout2d函数
    • 使用第三维作为通道。效果是要么黑色,要么红色,因为这是多整个像素操作,把像素置零。
%matplotlib inline
import torch
import matplotlib.pyplot as plt

org_imgs = plt.imread("datasets/hi.jpeg")
input = torch.from_numpy(org_imgs).double()

out = torch.nn.functional.dropout2d(input=input, p=0.5, training=True)   # 只对浮点数运算
# -----------------
ax1 = plt.subplot(121, title="原始图像")
ax1.imshow(org_imgs)    # 图像深度是3,表示彩色图像
ax2 = plt.subplot(122, title="dropout后的图像")
ax2.imshow(out.byte().numpy())

dropout2d是像素:对所有颜色通道

线性运算函数

  • 线性函数仅仅是针对所有维数的,但我们通常使用的还是二维矩阵。

linear函数

bilinear函数

linear使用例子

  1. 首先关注形状
import torch

x = torch.randn(2, 4)    # 
A = torch.randn(3, 4)
b = torch.randn(2, 3)

out = torch.nn.functional.linear(input=x, weight=A, bias=b)
print(out)
tensor([[ 2.6883,  1.2959,  0.0287],
        [-0.4045,  0.4580, -2.5265]])
  1. 然后关注计算规则(内积)。
import torch

x = torch.LongTensor(  # 2*4
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8]
    ]
)
A = torch.LongTensor(   # 3*4
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [1, 1, 1, 1]
    ]
)
b = torch.LongTensor(   # 2 * 3
    [
        [1, 2, 3],
        [5, 6, 7]
    ]
)

out = torch.nn.functional.linear(input=x, weight=A, bias=b)
print(out)
tensor([[ 31,  72,  13],
        [ 75, 180,  33]])
  1. 多维的情况
    • 关于维数的说明:
      • Input: 其中 * 表示任意多个维度
      • Weight:
      • Bias:
      • Output:
import torch

x = torch.randn(2, 3, 5, 4)    # N=2, * (3, 5),_=4
A = torch.randn(3, 4)          # _= 3, _=4
b = torch.randn(3)              #  _= 3
b = torch.Tensor([88, 888, 8888])

out = torch.nn.functional.linear(input=x, weight=A, bias=b)
print(out.shape)    # N=2,   * (3, 5), _= 3
print(out)
torch.Size([2, 3, 5, 3])
tensor([[[[  87.6084,  888.8325, 8889.0488],
          [  89.4753,  889.6735, 8886.3359],
          [  88.0262,  890.7296, 8890.6123],
          [  89.7283,  890.1259, 8886.5527],
          [  86.9266,  891.3016, 8888.4502]],

         [[  87.8339,  890.9385, 8889.3877],
          [  88.5911,  889.2175, 8889.3818],
          [  85.6238,  885.1033, 8887.4404],
          [  88.8761,  887.0152, 8885.6064],
          [  86.9773,  885.6030, 8887.9336]],

         [[  88.2102,  889.2548, 8889.2451],
          [  89.2577,  885.4579, 8883.8271],
          [  87.3587,  888.9655, 8887.9131],
          [  88.3702,  888.2765, 8886.4570],
          [  87.8151,  886.6364, 8887.6582]]],


        [[[  86.8274,  888.8477, 8889.2188],
          [  87.7344,  888.5159, 8889.4189],
          [  88.3876,  887.8715, 8888.4531],
          [  90.0545,  885.2833, 8887.1396],
          [  90.2269,  889.3709, 8885.2266]],

         [[  87.8483,  889.3448, 8888.0000],
          [  89.7446,  889.5375, 8888.2314],
          [  84.5236,  885.5975, 8887.9775],
          [  89.0541,  887.0644, 8885.5928],
          [  91.5662,  889.8510, 8885.7021]],

         [[  87.5693,  891.6489, 8890.9561],
          [  88.2609,  887.5566, 8888.3799],
          [  87.9360,  890.4555, 8888.3887],
          [  87.0874,  885.4625, 8887.5732],
          [  87.1704,  884.4638, 8889.4834]]]])
import torch

x = torch.randn(2, 4)    # N=2, * (3, 5),_=4
A = torch.randn(3, 4)          # _= 3, _=4
b = torch.randn(3)              #  _= 3
b = torch.Tensor([88, 888, 8888])

out = torch.nn.functional.linear(input=x, weight=A, bias=b)
print(out.shape)    # N=2,   * (3, 5), _= 3
print(out)
torch.Size([2, 3])
tensor([[  88.3087,  889.9603, 8887.1494],
        [  87.2756,  886.3957, 8887.5176]])

bilinear使用例子

  • 主要注意下形状即可。

    • Input1:
    • Input2:
    • Output:
    • weight:
    • bias:
  • 注意

    • 两个输入数据的中间 *表示一样的批量数据。
    • bilinear运算主要用于图像的双线性插值运算,比如图像放大:如果仅仅是对一个像素赋值变成4个,图像会模糊,采用线性插值采样,图像效果好得多。
import torch

input1 = torch.randn(3,2,4,3)      # 中间的2与4必须与下面的中间2与4一致
input2 = torch.randn(3,2,4,4)     # 中间的2与4必须与上面的中间2与4一致
weight = torch.randn(5,3, 4)      # 必须三维
bias = torch.randn(5)

out = torch.nn.functional.bilinear(input1=input1, input2=input2, weight=weight, bias=bias)
print(out.shape)
torch.Size([3, 2, 4, 5])

激活函数

  • 下面的激活函数一般都提供两个版本:
    • 返回版本
    • 修改版本(后缀_的函数)

threshold函版本

  • 线性函数的阈值,本质是relu的功能增强版本。
    torch.nn.functional.threshold(input, threshold, value, inplace=False)
    
  • 参数说明:

    • input:需要处理的数据,可以是任意shape
    • threshold:阈值
    • value:替代阈值以下值得值。
  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.threshold(input=x, threshold=2, value=4)
plt.plot(x, y, color=(1, 0, 0, 1))

[]
threshold函数

relu函数

  • 线性整流函数(Rectified Linear Unit, ReLU),又称修正线性单元;
    torch.nn.functional.relu(input, inplace=False) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.relu(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
relu函数

hardtanh函数

  • hard正切双曲线,是tanh的增强版本
    • 使用最大与最小限制输出值范围。默认限制在[-1, 1]之间。
    torch.nn.functional.hardtanh(input, min_val=-1., max_val=1., inplace=False) → Tensor
  • 参数说明:

    • min_val=-1.
    • max_val=1.,
  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.hardtanh(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
hardtanh函数

relu6

  • relu函数的特殊版本:
    • 输出范围现在0-6之间
    torch.nn.functional.relu6(input, inplace=False) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.relu6(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
relu6函数

elu函数

  • 指数运算修正的线性单元;
    torch.nn.functional.elu(input, alpha=1.0, inplace=False)
  • 参数说明:

    • input:被处理的数据
    • alpha=1.0:公式中的
  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.elu(input=x, alpha=1.0)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
elu函数

selu函数

  • selu公式如下;
    torch.nn.functional.selu(input, inplace=False) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.selu(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
selu函数

celu函数

  • 函数公式如下:
    torch.nn.functional.celu(input, alpha=1., inplace=False) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.celu(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
celu函数

leaky_relu函数

  • 函数公式如下:
    torch.nn.functional.leaky_relu(input, negative_slope=0.01, inplace=False) → Tensor
  • 参数说明:

    • negative_slope:就是公式中的
  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.leaky_relu(input=x, negative_slope=0.01)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
leaky_relu函数

prelu函数

  • 是leaky_relu函数参数化版本(weight需要是一个张量),下面公式中的乘法是叉乘。
  • 函数公式如下:
    torch.nn.functional.prelu(input, weight) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.prelu(input=x, weight=torch.Tensor([0.01]))
plt.plot(x, y, color=(1, 0, 0, 1))
[]
prelu函数

rrelu函数

  • 随机修正线性单元:
  • 函数公式如下:
    • 其中是服从[lower, upper)之间的均匀分布随机概率。

    torch.nn.functional.rrelu(input, lower=1./8, upper=1./3, training=False, inplace=False) → Tensor
  • 参数:

    • 指定均匀分布的区间范围的两个参数:
      • lower=1./8
      • upper=1./3
  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.rrelu(input=x, lower=0.4,  upper=0.6)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
rrelu函数

glu函数

  • 网管线性单元
  • 计算公式:
    • 其中函数就是sigmoid函数(下面会专门介绍)
    • 是矩阵叉乘(对应元素相乘)
    • 其中的是输入矩阵按照指定的维度一分为二形成的矩阵。
  • 注意:
    • 要求input至少是2D矩阵。而且被拆分的维度必须是偶数
    torch.nn.functional.glu(input, dim=-1) → Tensor
  • 例子代码
import torch
x = torch.Tensor(
    [
        [1, 2, 3, 4],
        [4, 5, 6, 7],
        [7, 8, 9, 10]
    ]
) 

y =  torch.nn.functional.glu(x, dim=-1)
print(y)
tensor([[0.9526, 1.9640],
        [3.9901, 4.9954],
        [6.9991, 7.9996]])

gelu函数

  • 函数公式是:
      • 其中是高斯分布函数(标准正态分布)。
    torch.nn.functional.gelu(input) → Tensor
  • 说明

    • 任何作用在标量上的函数对矩阵也是有效的,对矩阵的运算就是按照元素操作。
  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.gelu(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
gelu函数

logsigmoid函数

  • 是sigmoid函数再做log对数运算,函数公式如下:
    torch.nn.functional.logsigmoid(input) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.logsigmoid(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
logsigmoid函数

hardshrink函数

  • 分段限制收缩函数,公式如下:
    torch.nn.functional.hardshrink(input, lambd=0.5) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.hardshrink(input=x, lambd=3.0)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
hardshrink函数

tanhshrink

  • 正切双曲限制收缩函数,函数公式为:
    torch.nn.functional.tanhshrink(input) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.tanhshrink(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
tanhshrink函数

softsign函数

  • 符号函数的增强版本,表示公式如下:
    torch.nn.functional.softsign(input) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.softsign(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
softsign函数

softplus函数

  • softplus可以看作是ReLu的平滑,其函数公式如下:
    torch.nn.functional.softplus(input, beta=1, threshold=20) → Tensor
  • 因为softplus的导数是逻辑分布函数,所以上面beta参数与threshold参数是逻辑分布中对应的参数!

  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.softplus(input=x, beta=1, threshold=20)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
softplus函数
import torch
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)

y = 1 + x.exp()
y = y.log()
plt.plot(x, y, color=(1, 0, 0, 1))
[]
softplus函数实现过程

softmin函数

  • 是softmax函数的对偶函数
    • softmax是对数标准化
    torch.nn.functional.softmin(input, dim=None, _stacklevel=3, dtype=None)
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.softmin(input=x, dim=0)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
softmin函数

softmax函数

  • 函数公式是:

  • 支持多维,所以可以指定按照某个维度求和。

    torch.nn.functional.softmax(input, dim=None, _stacklevel=3, dtype=None)
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.softmax(input=x, dim=0)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
softmin函数
  • 手工实现softmax
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
s = 0
for xi in x:
    s += xi.exp()
y = x.exp()/s
plt.plot(x, y, color=(1, 0, 0, 1))
[]
softmin实现过程

softshrink函数

  • 函数公式为:
    torch.nn.functional.softshrink(input, lambd=0.5) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 1000)
y = torch.nn.functional.softshrink(input=x, lambd=3)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
softshrink函数

gumbel_softmax函数

  • Gumbel-Softmax distribution (Link 1 Link 2) :耿贝尔分布;
    torch.nn.functional.gumbel_softmax(logits, tau=1, hard=False, eps=1e-10, dim=-1)
  • 参数说明:

    • hard=False:离散化为one-hot向量
  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(0, 1, 100)
y = torch.nn.functional.gumbel_softmax(logits=x, tau=1, hard=False)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
gumbel_softmax函数
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(0, 1, 100)
y = torch.nn.functional.gumbel_softmax(logits=x, tau=1, hard=True)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
gumbel_softmax,hard=True

log_softmax函数

  • 对softmax做一个log对数运算
    torch.nn.functional.log_softmax(input, dim=None, _stacklevel=3, dtype=None)
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 100)
y = torch.nn.functional.log_softmax(input=x, dim=-1)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
log_softmax函数

tanh函数

  • 这是正切双曲线函数:
  • 一个可以使用自身表示其导数的函数:
    • \begin{align*} tanh^{'}(x)&=((e^x-e^{-x})(e^x+e^{-x}))^{'} \\ &=(e^x+e^{-x})(e^x+e^{-x})^{-1}-(e^x-e^{-x})(e^x+e^{-x})^{-2}(e^x-e^{-x})\\ &=1-\frac{(e^x-e^{-x})^{2}}{(e^x+e^{-x})^{2}}\\ &=1-tanh^2(x) \end{align*}
    torch.nn.functional.tanh(input) → Tensor
  • 例子代码
%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 100)
# y = torch.nn.functional.tanh(input=x)
y = torch.tanh(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
tanh函数

sigmoid函数

  • 函数公式:

  • 例子代码

%matplotlib inline
import torch
import matplotlib.pyplot as plt

x = torch.linspace(-10, 10, 100)
y = torch.sigmoid(input=x)
plt.plot(x, y, color=(1, 0, 0, 1))
[]
sigmoid函数

标准化函数

  • 标准函数提供了5个:
    • normalize:标准化
    • batch_norm:批量标准化
    • instance_norm:批处理实例标准化
    • layer_norm:层标准化
    • local_response_norm:局部响应标准化

normalize函数

    torch.nn.functional.normalize(
        input,    # 处理的数据
        p=2,     # 标准化使用的范数
        dim=1,   # 标准化维度
        eps=1e-12,    # 修正量(用来防止标准化中分母为0的情况)
        out=None)
  • 标准化计算公式:
import torch
x = torch.Tensor([1,2,3,4])

y = torch.nn.functional.normalize(x, p=2, dim=0)
print(y)
print(y.mean(), y.var())
print(x.norm())
print(x/x.norm())
tensor([0.1826, 0.3651, 0.5477, 0.7303])
tensor(0.4564) tensor(0.0556)
tensor(5.4772)
tensor([0.1826, 0.3651, 0.5477, 0.7303])
# 范数的计算:到原点的距离(范数定义的距离)为1.
import torch
x = torch.Tensor([1,2,3,4])
sum = 0
for x_ in x:
    sum += x_ * x_

print(sum)
print(sum.sqrt())
tensor(30.)
tensor(5.4772)

batch_norm函数

  • 深度学习都需要对数据做归一化

    1. 深度神经网络主要就是为了学习训练数据的分布,并在测试集上达到很好的泛化效果,但是,如果我们每一个batch输入的数据都具有不同的分布,显然会给网络的训练带来困难。
    2. 数据经过一层层网络计算后,其数据分布也在发生着变化,此现象称为Internal Covariate Shift,batchnorm就是用来解决这个分布变化的问题。
  • 对神经网络的每一层做归一化的问题;

    • 假设将每一层输出后的数据都归一化到0均值,1方差,满足正太分布,但是每一层的数据分布都是标准正太分布,导致其完全学习不到输入数据的特征,因为学习到的特征分布被归一化了,因此,直接对每一层做归一化显然是不合理的。
    • 但是如果稍作修改,加入可训练的参数做归一化,那就是BatchNorm实现的了。
  • Batchnorm本身上也是一种正则的方式,可以代替其他正则方式如dropout等;

    torch.nn.functional.batch_norm(
        input,                      # 需要处理的数据
        running_mean,          # 均值(用来做数据预测用的:对预测数据使用这个均值与方差来标准化)
        running_var,              # 方差(用来做数据预测用的)
        weight=None,            # 缩放系数   
        bias=None,                # 位移系数
        training=False, 
        momentum=0.1,          # 动量参数(每次训练过程中,用来修正running_mean与running_var的)
        eps=1e-05)                # 防止为0的误差量
import torch
x = torch.Tensor(
    [
        [1],
        [2],
        [3],
        [4]
    ]
)

m = torch.Tensor([0.0])
# m = x.mean(dim=0)
v = torch.Tensor([1.0])

w = torch.Tensor([1.0])     # w与b是需要学习的,因为标准化容易丢弃已经学习的规则,使用参数是为了保留已学习的规则。
w.requires_grad=True
b = torch.Tensor([0.0])
b.requires_grad=True

y = torch.nn.functional.batch_norm(
    input=x, 
    running_mean=m,      # 指定标准化需要的均值
    running_var=v,           # 指定标准需要的方差
    weight=w,                 # 指定需要训练的标准化特征
    bias=b,                     # 指定需要训练的标准化特征
    momentum=0.1)
print(y)   
print(m,v)

# momentum参数在函数中没有使用
tensor([[1.0000],
        [2.0000],
        [3.0000],
        [4.0000]], grad_fn=)
tensor([0.]) tensor([1.])
  • 上面还不是最适合的使用方式,下面是对实际场景的最直观使用。
    • 下面x的深度是3,所以m,v必须是3维数。
import torch
x= torch.randn(4, 3, 5, 5)   # 4张3通道5*5的图像

m = x.mean(dim=(0,2,3))   
v = x.var(dim=(0,2,3))
print(m,v)
w = torch.Tensor([1.0, 1.0, 1.0])     # w与b是需要学习的,因为标准化容易丢弃已经学习的规则,使用参数是为了保留已学习的规则。
w.requires_grad=True
b = torch.Tensor([0.0, 0.0, 0.0])
b.requires_grad=True

y = torch.nn.functional.batch_norm(
    input=x, 
    running_mean=m,      # 指定标准化需要的均值
    running_var=v,           # 指定标准需要的方差
    weight=w,                 # 指定需要训练的标准化特征
    bias=b,                     # 指定需要训练的标准化特征
    momentum=0.1)
print(y)   
print(m,v)

# momentum参数在函数中没有使用
tensor([-0.1099, -0.1201,  0.0899]) tensor([1.1323, 1.0076, 1.1978])
tensor([[[[ 0.6039, -0.5582,  0.4959, -0.6427, -0.5870],
          [-0.3643,  0.5706, -0.5763,  1.4945, -1.4511],
          [ 0.1614,  0.5990,  1.9546, -0.3642,  1.4048],
          [ 0.7057, -0.9043,  0.1523,  0.9368, -0.2871],
          [ 0.8770, -0.9029,  0.2469, -0.6572, -0.2440]],

         [[ 0.7871, -2.0743,  0.7447,  1.3778,  0.0870],
          [ 0.3714,  0.2540, -0.3870, -0.9554, -0.9491],
          [ 2.3781, -0.0893, -0.0280,  1.3762,  0.4648],
          [-1.1302, -1.2012,  1.0125,  1.7782,  0.1390],
          [-0.0499, -0.1794,  0.4153, -0.4797, -1.5406]],

         [[-0.3106,  0.3042, -2.6128, -0.6955,  0.1389],
          [ 0.6331,  0.5983, -0.3249, -1.0146, -0.3954],
          [ 0.7133, -1.6992, -0.0674, -0.0610, -0.1267],
          [ 2.2547,  1.1713, -1.6066,  1.9786,  1.5711],
          [ 0.9024, -0.9147,  0.6853,  0.2226, -0.0866]]],


        [[[-0.1178,  0.2178, -0.4152, -0.2686,  1.8236],
          [-1.4309, -1.3974, -0.2394,  0.4349, -1.5596],
          [ 0.6755,  0.3908, -0.9385,  0.2810,  0.5441],
          [ 0.7135,  0.4403, -0.0172, -0.0238,  1.2088],
          [ 0.7274,  1.1456, -0.8432, -2.3800, -2.0214]],

         [[-1.1411, -2.1205, -0.2992,  0.0374,  0.3259],
          [-0.1580, -0.8872, -0.0905,  0.2920,  0.3672],
          [ 0.6656,  0.5359, -0.9617, -1.1993,  1.9091],
          [-0.9763, -1.2720,  1.6294, -0.8532,  0.8935],
          [ 1.4322,  0.5476,  2.3484,  0.3687,  0.4523]],

         [[-0.3341,  1.3806,  1.0831,  0.4029, -0.8603],
          [-0.0656,  0.0882,  1.1263, -0.3221, -1.2238],
          [ 0.9934, -0.7986, -0.4356,  0.1994,  0.5767],
          [ 0.7159,  0.7112, -2.4808, -0.3498,  0.1422],
          [ 0.1981, -0.5962, -0.4935, -0.9984,  2.4134]]],


        [[[ 0.1386, -0.4204,  0.0246, -1.2291,  0.9505],
          [ 0.8621, -0.9966,  0.7689,  1.3110, -0.4741],
          [ 0.6832,  0.3085,  1.0335, -0.7198,  0.9119],
          [-0.8902, -0.5828, -0.5656,  0.1060, -0.7015],
          [ 0.7235, -2.8109, -1.7042, -0.1866, -1.0658]],

         [[-0.9406, -0.8973,  0.8829, -1.2684, -0.2581],
          [ 2.1365,  0.0305,  0.4322, -0.1121,  0.8947],
          [ 0.0875,  0.0843, -1.1963,  0.5078, -0.8428],
          [-0.3173, -1.0045, -1.4108,  1.7931,  0.2055],
          [ 0.1410, -0.9936,  0.4887, -0.7456, -1.8184]],

         [[ 0.5326, -0.0776, -0.2944,  1.2970,  0.3175],
          [ 1.0699,  0.5990,  0.6703, -0.7066, -0.8497],
          [-0.4794,  0.3368, -0.3240, -0.0839, -0.6898],
          [-0.4844,  0.6520, -0.9095,  0.6653, -0.4540],
          [-0.5475,  1.8319, -1.6593, -1.9774, -0.3549]]],


        [[[-0.0032, -0.0484, -0.2990,  0.7075, -0.6719],
          [ 1.5305,  0.8488,  0.4503,  2.0581,  0.4679],
          [ 0.0354, -1.0883,  1.6254, -2.1237,  0.4148],
          [-2.1199, -0.0477, -0.9596,  0.8312, -0.3866],
          [ 1.6314,  1.9948, -0.2880,  0.4639, -0.1125]],

         [[ 0.2379,  0.2749, -1.1225, -0.4368,  1.3602],
          [ 1.4522,  0.2326, -0.6224, -1.1355,  0.3085],
          [ 0.7286,  0.2441, -1.4076,  0.5067, -0.7492],
          [ 0.7412, -0.1160,  1.2024,  0.9920, -1.0792],
          [-1.1923,  0.6291, -1.0011, -0.9160,  1.0205]],

         [[ 0.2387, -0.9847,  0.7370,  1.5279, -0.9204],
          [ 0.8992,  1.4813,  0.6839, -0.2267, -1.3877],
          [ 0.2700,  0.4006,  0.8214, -0.4204, -0.7890],
          [-0.7622,  1.1744,  0.9095, -0.7127, -1.2161],
          [-0.9994, -2.5458,  1.1390, -0.1247,  0.3969]]]],
       grad_fn=)
tensor([-0.1099, -0.1201,  0.0899]) tensor([1.1323, 1.0076, 1.1978])
  • 关于batch_norm的一段代码,可以很好的诠释batch_norm的含义

    def Batchnorm_simple_for_train(x, gamma, beta, bn_param):
        """
        param:x    : 输入数据,设shape(B,L)
        param:gama : 缩放因子  γ
        param:beta : 平移因子  β
        param:bn_param   : batchnorm所需要的一些参数
            eps      : 接近0的数,防止分母出现0
            momentum : 动量参数,一般为0.9, 0.99, 0.999
            running_mean :滑动平均的方式计算新的均值,训练时计算,为测试数据做准备
            running_var  : 滑动平均的方式计算新的方差,训练时计算,为测试数据做准备
        """
        running_mean = bn_param['running_mean']  #shape = [B]
        running_var = bn_param['running_var']    #shape = [B]
        results = 0. # 建立一个新的变量

        x_mean=x.mean(axis=0)  # 计算x的均值
        x_var=x.var(axis=0)    # 计算方差
        x_normalized=(x-x_mean)/np.sqrt(x_var+eps)       # 归一化
        results = gamma * x_normalized + beta            # 缩放平移

        running_mean = momentum * running_mean + (1 - momentum) * x_mean
        running_var = momentum * running_var + (1 - momentum) * x_var

        #记录新的值
        bn_param['running_mean'] = running_mean
        bn_param['running_var'] = running_var 

        return results , bn_param


instance_norm函数

  • 与batch_norm,layer_norm类似的函数,区别在于:

    • 计算平均值的方式不同,最终把每个通道的和起来
    • [图片上传失败...(image-11e7d1-1569983607544)]
  • 将输入的图像shape记为[N, C, H, W],这几个方法主要的区别就是在,

    • Batch Norm是在batch上,对NHW做归一化,就是对每个单一通道输入进行归一化,这样做对小batchsize效果不好;
    • Layer Norm在通道方向上,对CHW归一化,就是对每个深度上的输入进行归一化,主要对RNN作用明显;
    • Instance Norm在图像像素上,对HW做归一化,对一个图像的长宽即对一个像素进行归一化,用在风格化迁移;
    • Group Norm将channel分组,有点类似于LN,只是GN把channel也进行了划分,细化,然后再做归一化;
    • Switchable Norm是将BN、LN、IN结合,赋予权重,让网络自己去学习归一化层应该使用什么方法。
  • instance_norm函数说明:
    torch.nn.functional.instance_norm(
        input, 
        running_mean=None,     # 可以为None
        running_var=None, 
        weight=None, 
        bias=None, 
        use_input_stats=True, momentum=0.1, eps=1e-05)
import torch
x= torch.randn(4, 3, 5, 5)   # 4张3通道5*5的图像

m = x.mean(dim=(0,2,3), keepdim=False)   # N(0),C(1),H(2),W(3)
v = x.var(dim=(0,2,3), keepdim=False)
print(m.shape)
w = torch.ones(3)     # w与b是需要学习的,因为标准化容易丢弃已经学习的规则,使用参数是为了保留已学习的规则。
w.requires_grad=True
b = torch.zeros(3)
b.requires_grad=True

y = torch.nn.functional.instance_norm(
    input=x, 
    running_mean=m,    
    running_var=v,
    weight=w, bias=b
)
print(y)   
# 比较batch_norm与instance_norm的结果差别
y = torch.nn.functional.batch_norm(
    input=x, 
    running_mean=m,    
    running_var=v,
    weight=w, bias=b
)
print(y)   
torch.Size([3])
tensor([[[[-1.3300e+00, -1.0276e+00,  3.0897e-01,  9.5767e-02,  3.2338e-01],
          [-4.1176e-01,  7.4911e-01, -6.9988e-01,  2.9321e-01,  7.2987e-01],
          [ 1.3905e+00,  5.4397e-01,  1.2827e-02,  3.2809e-01,  7.4175e-01],
          [ 3.9900e-01, -2.5250e+00,  6.4288e-01,  1.8031e+00, -6.0249e-02],
          [ 1.0510e+00, -5.5906e-01,  2.5902e-01, -2.1903e+00, -8.6867e-01]],

         [[ 4.4713e-01,  8.9750e-01, -9.6316e-01,  3.1501e-01,  1.5213e+00],
          [-3.3827e-01, -7.3737e-01, -9.3462e-01,  1.7493e+00,  1.0172e+00],
          [ 4.7460e-01, -2.6951e-01, -1.1510e+00, -7.1324e-01, -1.1702e+00],
          [ 1.0441e+00, -1.7336e+00,  1.2532e-01, -7.4906e-01, -8.4268e-01],
          [ 1.6433e-01,  1.9831e+00, -6.9415e-01, -6.0049e-01,  1.1584e+00]],

         [[-2.3036e+00,  7.9183e-01, -2.5915e-01,  1.3214e+00, -1.5231e+00],
          [ 4.1672e-02,  5.2620e-01,  3.9970e-01,  4.4207e-01, -2.3129e-01],
          [-4.2022e-01, -8.8784e-01,  8.0396e-01,  1.7451e+00, -6.7207e-02],
          [ 9.6801e-01,  8.7536e-01,  1.4504e+00, -4.8293e-01, -1.4823e+00],
          [ 3.8419e-01,  3.7225e-01, -3.8346e-01, -4.2881e-01, -1.6523e+00]]],


        [[[-5.7823e-01, -3.3143e-01,  7.1775e-01,  2.1239e-01,  3.6560e-01],
          [-1.7156e-01, -9.9428e-01,  1.9243e-01,  8.9780e-01, -1.5584e+00],
          [-1.8803e+00, -1.2125e-02, -7.6846e-01, -3.1888e-01, -4.6432e-01],
          [ 7.6454e-01,  2.7620e-02, -1.4467e+00,  6.5572e-01, -9.6305e-01],
          [-2.7112e-01,  1.7859e+00,  1.9314e+00,  2.0155e+00,  1.9219e-01]],

         [[-1.7664e+00,  1.5730e+00, -8.9284e-01,  1.1217e+00, -1.0072e+00],
          [ 8.7060e-01, -4.5303e-01,  1.1819e+00, -3.9239e-01, -7.1941e-02],
          [-1.8391e+00, -1.2180e+00, -9.6703e-01,  1.1305e+00,  3.5450e-01],
          [ 6.3686e-01,  1.0018e+00, -5.7442e-01, -8.5710e-01, -9.9438e-01],
          [-1.9725e-01,  9.4404e-01,  9.4887e-01,  1.0814e+00,  3.8601e-01]],

         [[ 4.1552e-01, -6.7624e-01,  1.1387e+00,  2.0360e+00,  2.3363e-01],
          [ 1.0976e+00, -1.5366e-01,  4.5983e-02, -4.4905e-01,  3.7788e-01],
          [-3.0292e-01, -5.5900e-01, -2.4216e+00,  3.2742e-01, -1.7846e+00],
          [ 1.0120e+00, -7.8423e-01, -6.4370e-01, -1.2993e+00,  3.6975e-01],
          [ 9.7618e-01, -6.3158e-01, -3.9939e-01,  1.3506e+00,  7.2390e-01]]],


        [[[ 1.0768e+00,  8.2844e-02, -2.2382e-01,  2.1644e+00, -1.5242e+00],
          [-1.7984e-01, -5.6175e-01,  2.4898e-01, -5.0420e-01, -8.5796e-01],
          [ 1.5355e+00,  8.2799e-01,  6.5538e-01, -1.5339e+00, -9.7581e-01],
          [ 6.1572e-02, -6.4004e-01,  4.7675e-01, -1.4959e+00, -1.0269e+00],
          [ 1.0670e+00,  1.4524e+00, -6.9493e-01, -3.3628e-01,  9.0577e-01]],

         [[-9.0222e-01,  9.3811e-01, -1.0737e+00, -5.2899e-01, -1.5509e+00],
          [ 5.9876e-01, -5.6182e-01, -1.3897e+00, -1.9862e+00, -5.7414e-01],
          [ 1.9665e+00,  1.4921e+00, -6.4958e-01,  1.1793e-01,  3.5676e-01],
          [ 2.9828e-01,  4.0369e-01,  1.0687e+00,  1.9175e-01,  7.0528e-02],
          [ 9.6439e-01, -7.0567e-01,  1.6306e+00, -5.3084e-01,  3.5556e-01]],

         [[-7.4705e-01,  2.0131e-01,  9.2345e-01, -2.1607e+00, -9.0636e-01],
          [ 1.9722e-01,  1.4994e+00, -2.2590e-01,  4.1395e-01, -7.3280e-02],
          [-5.7261e-01,  9.1539e-01, -8.1471e-01,  3.0324e-01,  1.4799e+00],
          [-9.1599e-01, -1.5451e+00,  9.5537e-01,  1.8283e+00, -7.3733e-01],
          [-1.1077e+00, -8.3597e-01,  7.4975e-01,  2.5025e-01,  9.2512e-01]]],


        [[[ 4.3015e-02, -1.1650e+00,  1.7200e-02, -1.4198e+00,  1.6581e+00],
          [ 1.8173e-01, -8.0867e-02,  3.9920e-01, -4.2110e-01,  1.6406e+00],
          [ 7.3747e-01,  9.6860e-01, -1.3032e+00, -1.1416e+00,  7.8118e-01],
          [ 2.5386e+00,  1.9666e-01,  4.3760e-01,  5.3153e-02, -4.3334e-01],
          [-1.3547e+00, -1.1957e+00, -6.1150e-02, -5.3436e-01, -5.4225e-01]],

         [[ 1.6825e+00, -5.6726e-01,  7.8480e-01,  8.8852e-02, -9.9347e-01],
          [-1.0618e+00, -1.7799e+00,  1.7843e-01,  5.7744e-01,  7.4290e-01],
          [ 6.0726e-01, -1.3402e+00,  2.0730e-01, -2.3312e+00, -2.5911e-02],
          [-3.1424e-01, -1.2857e-03,  2.2741e-01,  1.0183e+00,  3.0547e-01],
          [-8.4714e-01,  1.1635e+00, -5.9346e-01,  1.8763e+00,  3.9539e-01]],

         [[ 9.8080e-01,  1.2992e-01, -9.5844e-01, -1.7077e+00, -5.6559e-01],
          [ 7.4964e-01,  4.8532e-01, -1.3676e-01, -3.8980e-01, -1.4458e-01],
          [-5.6245e-02,  1.3231e+00, -1.0872e+00,  2.4868e+00,  1.4366e+00],
          [ 2.5883e-01, -7.0243e-01, -8.8365e-02,  2.2908e-01, -2.3850e+00],
          [-9.2475e-02, -7.5162e-01,  6.7078e-01,  5.5210e-01, -2.3674e-01]]]],
       grad_fn=)
tensor([[[[-1.5079, -1.2248,  0.0263, -0.1733,  0.0398],
          [-0.6484,  0.4383, -0.9181,  0.0115,  0.4203],
          [ 1.0386,  0.2462, -0.2509,  0.0442,  0.4314],
          [ 0.1105, -2.6264,  0.3388,  1.4249, -0.3193],
          [ 0.7209, -0.7862, -0.0205, -2.3132, -1.0761]],

         [[ 0.6112,  1.0795, -0.8553,  0.4738,  1.7282],
          [-0.2055, -0.6205, -0.8256,  1.9652,  1.2040],
          [ 0.6398, -0.1340, -1.0506, -0.5954, -1.0706],
          [ 1.2319, -1.6564,  0.2766, -0.6327, -0.7300],
          [ 0.3171,  2.2084, -0.5756, -0.4782,  1.3508]],

         [[-2.4660,  1.0380, -0.1517,  1.6375, -1.5826],
          [ 0.1888,  0.7373,  0.5941,  0.6421, -0.1202],
          [-0.3341, -0.8634,  1.0517,  2.1171,  0.0656],
          [ 1.2374,  1.1325,  1.7835, -0.4051, -1.5364],
          [ 0.5765,  0.5630, -0.2924, -0.3438, -1.7287]]],


        [[[-0.5347, -0.3214,  0.5852,  0.1485,  0.2809],
          [-0.1833, -0.8942,  0.1313,  0.7408, -1.3817],
          [-1.6598, -0.0455, -0.6990, -0.3106, -0.4362],
          [ 0.6257, -0.0111, -1.2851,  0.5316, -0.8672],
          [-0.2693,  1.5082,  1.6340,  1.7067,  0.1311]],

         [[-2.0110,  1.5980, -1.0669,  1.1103, -1.1904],
          [ 0.8389, -0.5915,  1.1754, -0.5260, -0.1797],
          [-2.0895, -1.4182, -1.1470,  1.1198,  0.2812],
          [ 0.5863,  0.9807, -0.7227, -1.0282, -1.1766],
          [-0.3151,  0.9183,  0.9235,  1.0667,  0.3152]],

         [[ 0.3790, -0.6094,  1.0336,  1.8460,  0.2143],
          [ 0.9964, -0.1363,  0.0444, -0.4037,  0.3449],
          [-0.2714, -0.5032, -2.1894,  0.2992, -1.6127],
          [ 0.9190, -0.7071, -0.5799, -1.1733,  0.3375],
          [ 0.8865, -0.5689, -0.3587,  1.2254,  0.6581]]],


        [[[ 1.2406,  0.1963, -0.1259,  2.3834, -1.4923],
          [-0.0797, -0.4810,  0.3708, -0.4205, -0.7922],
          [ 1.7225,  0.9792,  0.7978, -1.5024, -0.9161],
          [ 0.1739, -0.5633,  0.6102, -1.4625, -0.9697],
          [ 1.2304,  1.6353, -0.6209, -0.2441,  1.0609]],

         [[-0.8363,  0.5258, -0.9632, -0.5601, -1.3164],
          [ 0.2746, -0.5844, -1.1971, -1.6386, -0.5935],
          [ 1.2869,  0.9359, -0.6493, -0.0813,  0.0955],
          [ 0.0522,  0.1302,  0.6225, -0.0266, -0.1163],
          [ 0.5452, -0.6908,  1.0383, -0.5614,  0.0946]],

         [[-0.6772,  0.1907,  0.8516, -1.9708, -0.8229],
          [ 0.1870,  1.3787, -0.2002,  0.3853, -0.0606],
          [-0.5175,  0.8442, -0.7391,  0.2840,  1.3608],
          [-0.8318, -1.4075,  0.8808,  1.6797, -0.6683],
          [-1.0072, -0.7585,  0.6926,  0.2355,  0.8531]]],


        [[[ 0.2341, -1.0415,  0.2069, -1.3105,  1.9396],
          [ 0.3806,  0.1033,  0.6102, -0.2559,  1.9211],
          [ 0.9674,  1.2115, -1.1874, -1.0168,  1.0136],
          [ 2.8693,  0.3964,  0.6508,  0.2448, -0.2689],
          [-1.2418, -1.0739,  0.1241, -0.3755, -0.3839]],

         [[ 1.8749, -0.4660,  0.9409,  0.2167, -0.9095],
          [-0.9806, -1.7278,  0.3099,  0.7251,  0.8973],
          [ 0.7561, -1.2703,  0.3399, -2.3015,  0.0973],
          [-0.2027,  0.1229,  0.3609,  1.1838,  0.4421],
          [-0.7572,  1.3349, -0.4933,  2.0766,  0.5357]],

         [[ 0.8154, -0.0229, -1.0953, -1.8335, -0.7082],
          [ 0.5876,  0.3272, -0.2857, -0.5350, -0.2934],
          [-0.2064,  1.1527, -1.2222,  2.2992,  1.2645],
          [ 0.1041, -0.8430, -0.2380,  0.0748, -2.5008],
          [-0.2421, -0.8915,  0.5100,  0.3930, -0.3842]]]],
       grad_fn=)

layer_norm函数

  • 对指定的输入中最后几个维度标准化
    torch.nn.functional.layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-05)
import torch
x= torch.randn(4, 3, 5, 5)   # 4张3通道5*5的图像

w = torch.ones(3, 5, 5)     # 对最后两个维度做标准化
w.requires_grad=True
b = torch.zeros(3, 5,5)
b.requires_grad=True

y = torch.nn.functional.layer_norm(
    input=x, 
    normalized_shape=(3, 5, 5),
    weight=w, bias=b
)
print(y[0,0,:,:]) 
tensor([[ 0.0917,  0.2445,  0.1294,  0.0352,  0.5847],
        [ 1.7303, -1.4383, -1.1723,  0.3757,  0.1029],
        [ 0.1677, -0.1781,  1.3524, -0.0983, -0.3715],
        [ 1.7907, -0.6600,  2.0479, -0.0905, -0.1329],
        [ 0.6516,  0.1149,  0.6535, -0.3212,  0.4425]],
       grad_fn=)

距离函数

  • Torch提供三种距离计算方式:

    • 计算两个向量的欧氏距离(2-范数):pairwise_distance
    • 计算相似距离(两个向量夹角的余弦):cosine_similarity
      • 这个实际上是两个矩阵的相关性度量(向量正交就是无关,夹角90度,余弦为0;向量线性相关,夹角0度,余弦为1)
    • 计算矩阵每行之间的欧氏距离:pdist
  • 注意:

    • 实际在数学上根据不同的应用,有很多种距离的定义方式。
  • 下面使用例子说明:

pairwise_distance函数

    torch.nn.functional.pairwise_distance(x1, x2, p=2.0, eps=1e-06, keepdim=False)
import torch
# 两个点之间的距离
t1 = torch.Tensor([[0, 1]])
t2 = torch.Tensor([[1, 0]])

print(torch.nn.functional.pairwise_distance(t1, t2))
tensor([1.4142])
import torch
# 对应两个向量之间的距离,行数相同(1->1),否则其中一个只能是0行(1->多)。
t1 = torch.Tensor(
    [
        [0, 1],
        [0, 0]
    ]
)
t2 = torch.Tensor(
    [
        [1, 0],
        [0,0]
    ]
)

print(torch.nn.functional.pairwise_distance(t1, t2))
tensor([1.4142e+00, 1.4142e-06])

cosine_similarity函数

    torch.nn.functional.cosine_similarity(x1, x2, dim=1, eps=1e-8) → Tensor
t1 = torch.Tensor(
    [
        [0, 1],
        [0, 1]
    ]
)
t2 = torch.Tensor(
    [
        [1, 0],
        [0,1]
    ]
)

print(torch.nn.functional.cosine_similarity(t1, t2, dim=1))   # 按照行计算相似度
tensor([0., 1.])

pdist函数

    torch.nn.functional.pdist(input, p=2) → Tensor
t1 = torch.Tensor(
    [
        [0, 1],
        [1, 1],
        [0.5, 0.5],
        [0,0]
    ]
)

print(torch.nn.functional.pdist(t1))   # 按照全排列方式计算
tensor([1.0000, 0.7071, 1.0000, 0.7071, 1.4142, 0.7071])

你可能感兴趣的:(TORCH02-02:Torch常见机器学习函数)