pytorch---第一弹

快来打我* 2022-03-10 03:06 186阅读 0赞

# pytorch #

pytorch是美国互联网巨头Facebook在深度学习框架Torch的基础上使用Python进行重写的一个全新的深度学习框架，它更像是numpy的替代物，不仅继承了numpy的众多优点，和支持GPUS计算，在计算效率上比Numpy更有明显的优势，不仅如此，pytorch还有丰富的API，可以快速完成深度学习模型的搭建和训练。所以pytorch一经宣布，就受到了众多开发人员和科研人员的追捧和喜爱，称为AI从业者的重要工具之一

# pytorch中的tensor #

## Tensor的数据类型 ##

在使用tensor的时候，我们首先要掌握如何使用tensor来定义不同的数类型的变量：

*  torch.FloatTensor：用于生成数据类型为浮点型的Tensor，传递给Torch.FloatTensor的参数可以是一个列表，也可以是一个维度值

# 示例代码
    import torch
    # 生成一个2行3列的float=型数据
    a = torch.FloatTensor(2, 3)
    b = torch.FloatTensor([2, 3, 4])   # 输出的都是浮点型的数据

运行结果：

tensor([[3.8692e+25, 9.1836e-39, 1.2771e-40],
            [9.0079e+15, 1.6751e-37, 2.9775e-41]])
    tensor([2., 3., 4.])

*  torch.IntTensor：用于生成数据类型为整型的Tensor，传递给torch.IntTensor的参数可以是一个列表，也可以是一个维度值

# 示例代码
    a = torch.IntTensor(2, 3)
    b = torch.IntTensor([1, 2, 3.4])
    print(a)
    print(b)

运行结果：

tensor([[1778386306,    6553601,      91136],
            [1509950083,   40108034,      21248]], dtype=torch.int32)
    tensor([1, 2, 3], dtype=torch.int32)

*  torch.rand：用于生成数据类型为浮点数且维度指定的随Tensor，和在numpy中使用numpy.rand生成随机数的方法类似，随机生成的浮点数据在0-1之间
 *  torch.randn：用于生成数据类型为浮点型且维度指定的随机Tensor，和numpy.randn生成随机数的方法类似，随机生成的浮点数的取值满足均值为0，方差为1的正态分布

# 随机生成的0-1之间的数据
    a = torch.rand(2, 3)
    # 随机生成的浮点数满足均值为0，方差为1的正太分布
    b = torch.randn(2, 3)
    c = torch.range(1, 20, 1)
    print(a)
    print(b)
    print(c)

运行结果：

tensor([[0.6123, 0.3002, 0.6034],
            [0.1658, 0.7345, 0.0285]])
    tensor([[ 0.7916, -0.8456,  1.2073],
            [ 0.8003,  0.4896, -1.8763]])
    tensor([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13., 14.,
            15., 16., 17., 18., 19., 20.])

*  torch.zeros：用于生成数据类型为浮点型且维度指定的Tensor，不过这个浮点型的Tensor中的元素为全部为0，和numpy中的函数一样

## Tensor的运算 ##

*  torch.abs：将参数传递到torch.abs后返回输入参数的绝对值作为输出，输入参数必须是一个Tensor数据类型的变量

a = torch.randn(2, 3)
    b = torch.abs(a)
    print(a)
    print(b)

运行结果：

tensor([[ 0.8039,  0.9477, -0.3469],
            [-0.4703, -0.3018,  0.1491]])
    tensor([[0.8039, 0.9477, 0.3469],
            [0.4703, 0.3018, 0.1491]])

*  torch.add：将参数传递到torch.add后返回输入参数的求和结果作为输出，输入参数既可以全部是Tensor数据类型的变量，也可以一个是Tensor数据类型的变量，另一个是变量

a = torch.randn(2, 3)
    b = torch.randn(2, 3)
    c = torch.add(a, b)
    d = torch.add(a, 10)
    print(a)
    print(b)
    print(c)
    print(d)

运行结果：

tensor([[-0.5985, -1.5116, -0.6491],
            [-1.5258, -0.4351, -0.6229]])
    tensor([[-1.3326,  3.0326,  1.4990],
            [-0.0968,  0.4948,  0.5850]])
    tensor([[-1.9311,  1.5210,  0.8499],
            [-1.6226,  0.0598, -0.0379]])
    tensor([[9.4015, 8.4884, 9.3509],
            [8.4742, 9.5649, 9.3771]])

*  torch.clamp：对输入参数按照自定义的范围进行裁剪，最后将参数裁剪的结果作为输出；所以输入参数一共有三个，分别是需要进行裁剪的Tensor数据类型的变量、裁剪的上边界和下边界，具体的裁剪过程是：使用变量中的每个元素分别和裁剪的上边界和下边界进行比较，如果元素的值小于裁剪的下边界的值，该元素就被重写成裁剪的下边界的值；同理，如果元素的值大于裁剪的上边界的值，该元素就被重写成裁剪的上边界的值

a = torch.randn(2, 3)
    b = torch.clamp(a, -0.1, 0.1)
    print(a)
    print(b)

运行结果：

tensor([[ 0.1706, -0.4271, -0.8459],
            [ 0.5558,  0.9731, -0.0846]])
    tensor([[ 0.1000, -0.1000, -0.1000],
            [ 0.1000,  0.1000, -0.0846]])

*  torch.div：将参数传递到torch.div后返回输入参数的求商结果作为输出，同样，参与运算的参数可以全部是Tensor数据类型的变量，也可以是Tensor数据类型的变量和标量的集合

a = torch.randn(2, 3)
    b = torch.randn(2, 3)
    c = torch.div(a, b)
    d = torch.div(a, 10)
    print(a)
    print(b)
    print(c)
    print(d)

运行结果：

tensor([[ 1.7851, -1.6694, -0.2189],
            [-0.6435, -1.3177, -0.5319]])
    tensor([[-0.4307,  0.5083, -0.3014],
            [ 0.4740,  0.4095, -0.2112]])
    tensor([[-4.1445, -3.2842,  0.7263],
            [-1.3574, -3.2175,  2.5185]])
    tensor([[ 0.1785, -0.1669, -0.0219],
            [-0.0643, -0.1318, -0.0532]])

*  torch.mul：将参数传递到torch.mul后将输入参数求积的结果作为输出，参与运算的参数可以全部是Tensor数据类型的变量，也可以是tensor数据类型的变量和标量的组合

a = torch.randn(2, 3)
    b = torch.randn(2, 3)
    c = torch.mul(a, b)
    d = torch.mul(a, 10)
    print(a)
    print(b)
    print(a*b)
    print(c)
    print(d)

运行结果：

tensor([[-0.2620, -0.4886,  1.0385],
            [ 0.1834,  0.6705, -0.2801]])
    tensor([[ 0.0839,  0.0342, -0.2943],
            [ 1.4836, -0.7000, -0.0266]])
    tensor([[-0.0220, -0.0167, -0.3056],
            [ 0.2721, -0.4694,  0.0075]])
    tensor([[-0.0220, -0.0167, -0.3056],
            [ 0.2721, -0.4694,  0.0075]])
    tensor([[-2.6200, -4.8860, 10.3854],
            [ 1.8337,  6.7051, -2.8006]])

*  torch.pow：将参数传递到torch.pow后返回输入参数的求幂结果作为输出，参与运算的参数可以全部是Tensor数据类型的变量，也可以是Tensor数据类型的变量和标量的组合

a = torch.randn(2, 3)
    b = torch.pow(a, 3)
    print(a)
    print(b)

运行结果：

tensor([[ 0.3428,  2.0598, -0.9102],
            [-0.3843,  0.0110, -0.9580]])
    tensor([[ 4.0300e-02,  8.7397e+00, -7.5415e-01],
            [-5.6752e-02,  1.3414e-06, -8.7933e-01]])

*  torch.mm：将参数传递到torch.mm后返回输入参数的求积结果作为输出，不过这个求积的方式和之前的torch.mul不一样，torch.mm运用矩阵之间的运算规则进行计算，所以被传入的参数会被当做矩阵进行处理，参数的维度自然也要满足矩阵乘法的前提条件，即前一个矩阵的行数必须要和后一个矩阵的列数相同，否则不能同时进行计算
 *  torch.mv：将参数传递到torch.mv后返回输入参数的求积结果进行输出，运用矩阵与向量之间的乘法规则进行计算，被传入的参数中第一个参数代表矩阵，第二个参数代表向量，顺序不能颠倒

a = torch.randn(2, 3)
    b = torch.randn(3)
    c = torch.mv(a, b)
    print(a)
    print(b)
    print(c)

运行结果：

tensor([[ 0.5708,  0.7970,  0.5793],
            [ 0.9776,  1.1962, -1.8733]])
    tensor([-0.0838,  0.9503, -0.2349])
    tensor([0.5736, 1.4949])