pytorch 常见API实践

已于 2022-05-21 22:37:16 修改
阅读量2.6k 收藏 1
点赞数
分类专栏： pytorch python 文章标签： 深度学习 pytorch python
于 2022-03-25 19:17:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scar2016/article/details/123743077
版权
pytorch 同时被 2 个专栏收录
148 篇文章 28 订阅
订阅专栏
python
75 篇文章 2 订阅
订阅专栏

文章目录

1. torch.bernouli

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

input : 表示的是一个概率值组成的矩阵
output：表示的是一个跟input同等大小的矩阵，输出矩阵是来自伯努利分布
从伯努利分布中绘制二进制随机数(0或1)。

  • 举例：
    假设我们input矩阵如下：
input_rand=tensor([[0.5564, 0.0900, 0.8406, 0.7404],
        [0.9572, 0.7736, 0.4841, 0.6658],
        [0.7223, 0.0511, 0.8271, 0.8581]])

[0.5564,0.0900,0.8406,0.7404]表示：
0.5565 概 率 抽 到 1 0.5565概率抽到\qquad1 0.5565概率抽到1
0.0900 概 率 抽 到 1 0.0900概率抽到\qquad1 0.0900概率抽到1
0.8406 概 率 抽 到 1 0.8406概率抽到\qquad1 0.8406概率抽到1
0.7404 概 率 抽 到 1 0.7404概率抽到\qquad1 0.7404概率抽到1

  • 测试代码如下：
import torch
from torch import nn

# draw the sample from [0,1)，shape is (3,4);
# input_rand is probability to get the value 1
input_rand = torch.rand((3,4))
# draw the sample from bernoulli distribution;the probability is input_rand
output_rand = torch.bernoulli(input_rand)

# get a tensor filled all the value ones
input_ones = torch.ones((3,4))
# the probability is 1 ; so the output is all 1
output_ones = torch.bernoulli(input_ones)

# get a tensor filled all the value zeros
input_zeros = torch.zeros((3,4))

# the probability is 0 ; so the output is all 0
output_zeros = torch.bernoulli(input_zeros)
print(f"input_rand={input_rand}")
print(f"output_rand={output_rand}")
print("*"*50)
print(f"input_zeros={input_zeros}")
print(f"output_zeros={output_zeros}")
print("*"*50)
print(f"input_ones={input_ones}")
print(f"output_ones={output_ones}")

input_rand=tensor([[0.3222, 0.4630, 0.8227, 0.6225],
        [0.3587, 0.6961, 0.6875, 0.9904],
        [0.4817, 0.5500, 0.9436, 0.0660]])
output_rand=tensor([[0., 0., 1., 1.],
        [0., 1., 0., 1.],
        [1., 1., 1., 0.]])
**************************************************
input_zeros=tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
output_zeros=tensor([[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]])
**************************************************
input_ones=tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
output_ones=tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])

2. Tensor.masked_fill_(mask, value)

使用mask为True的值填充自张量的元素。掩模的形状必须与潜在张量的形状一致。
将一个张量中的元素根据mask值为真去替换，替换成value值，False值保持不变

import torch

# input tensor x
x = torch.arange(12.).reshape((3,4))

# get a tensor filled with 0,1 with the same shape to input
prob = torch.bernoulli(torch.rand(3,4))

# if the value in the prob is equal to 1 ,replace 888 to it ;
# the others keep the same 
y = x.masked_fill(prob==1,value=888)
print(f"x={x}")
print(f"prob={prob}")
print(f"y={y}")

x=tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]])
prob=tensor([[1., 1., 1., 1.],
        [1., 0., 1., 0.],
        [0., 1., 1., 1.]])
y=tensor([[888., 888., 888., 888.],
        [888.,   5., 888.,   7.],
        [  8., 888., 888., 888.]])

3. torch.NLLLOSS

4. nn.Conv2d

在这里插入图片描述

import torch
from torch import nn

# 目标：将一个输入为input = (1,2,3,3)
# 经过卷积my_conv = nn.Conv2d(2, 3, 2)；
# 输出output = (1,3,2,2)
# 步骤如下：
# 将卷积变成形状为(in_channel=2,weight=2,height=2),跟输入的(in_channel=2,weight=3,height=3)匹配
# 为了满足输出的通道数out_channel=3,那么我们只需要将卷积核复制3次 (2,2,2) -> (3,2,2,2)
# 也是就是得到my_conv2d.weights.shape=(3,2,2,2);
# 同理 my_conv2d.bias.shape = (3)


input = torch.Tensor([[[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[0, 1, 2], [3, 4, 5], [6, 7, 8]]]])
print(f"input.shape={input.shape}")
# input.shape=torch.Size([batch_size=1, in_channel=2, weight=3, height=3])
print(f"input={input}")
# my_conv = nn.Conv2d(in_channel=2, ou_channel=3, kernel_size=2x2)
my_conv = nn.Conv2d(2, 3, 2)
weight = torch.Tensor([[[[1,2],[3,4]],[[0,1],[2,3]]]])
weight = torch.repeat_interleave(weight,3,dim=0)
my_conv.weight = nn.Parameter(weight)
bias = torch.Tensor([0])
bias = torch.repeat_interleave(bias,3,dim=0)
print(f"my_conv.weight.shape={my_conv.weight.shape}")
print(f"my_conv.bias.shape={my_conv.bias.shape}")
print(f"my_conv.weight={my_conv.weight}")
print(f"my_conv.bias={my_conv.bias}")
my_conv.bias = nn.Parameter(bias)
output = my_conv(input)
print(f"output.shape={output.shape}")
print(f"output={output}")


input.shape=torch.Size([1, 2, 3, 3])
input=tensor([[[[1., 2., 3.],
          [4., 5., 6.],
          [7., 8., 9.]],

         [[0., 1., 2.],
          [3., 4., 5.],
          [6., 7., 8.]]]])
my_conv.weight.shape=torch.Size([3, 2, 2, 2])
my_conv.bias.shape=torch.Size([3])
my_conv.weight=Parameter containing:
tensor([[[[1., 2.],
          [3., 4.]],

         [[0., 1.],
          [2., 3.]]],


        [[[1., 2.],
          [3., 4.]],

         [[0., 1.],
          [2., 3.]]],


        [[[1., 2.],
          [3., 4.]],

         [[0., 1.],
          [2., 3.]]]], requires_grad=True)
my_conv.bias=Parameter containing:
tensor([ 0.0517,  0.2091, -0.1445], requires_grad=True)
output.shape=torch.Size([1, 3, 2, 2])
output=tensor([[[[ 56.,  72.],
          [104., 120.]],

         [[ 56.,  72.],
          [104., 120.]],

         [[ 56.,  72.],
          [104., 120.]]]], grad_fn=<ThnnConv2DBackward>)

5. torch.randint

返回一个张量，张量来自于[low,high)中，size为最后行程张量的大小

torch.randint(low=0, high, size, \*, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor

import torch
# 创建一个3行4列的矩阵，矩阵的值取值[2,5)的整数值
x = torch.randint(low=2, high=5, size=(3, 4))
print(f"x={x}")
# x=tensor([[4, 4, 3, 2],
#         [4, 4, 2, 4],
#         [4, 3, 2, 2]])

6. tensor.to

主要作用是对张量的精度进行转换

# torch.Tensor 默认是float32的精度
m = torch.Tensor([2,4])

# 将张量的精度转换成torch.int32
n = m.to(torch.int32)

print(f"m={m.dtype}")
# m=torch.float32

print(f"n={n.dtype}")
# n=torch.int32

7. tensor.ge()&torch.masked_select

  • tensor.ge()；
    input.ge(x) 将input里面的所有元素跟x进行比较，input_value>=x返回True，否则False
  • torch.masked_select
    torch.masked_select(input,mask):根据mask中True值，将对应于input位的数据抽取出来，返回到一维张量中
  • 代码
import torch
# 从一个均值为0，方差为1的正太分布中抽取数据得到一个3行4列矩阵
input = torch.randn((3, 4))
print(f"x_input={input}")
# 将 矩阵X中的值跟0.5比较，大于等于0.5返回True，小于0.5返回False
mask = input.ge(0.5)
print(f"mask={mask}")
# 根据mask矩阵中的True，将对应True的input里面的值抽取出来，返回一维张量
output = torch.masked_select(input,mask)
print(f"output={output}")
  • 结果
x_input=tensor([[-2.0118, -0.4704,  2.7249,  1.6469],
        [-2.1512,  0.6178,  2.4700,  0.1588],
        [ 0.2585, -0.1287,  0.6908, -0.5606]])
mask=tensor([[False, False,  True,  True],
        [False,  True,  True, False],
        [False, False,  True, False]])
output=tensor([2.7249, 1.6469, 0.6178, 2.4700, 0.6908])

8. torch.triu

torch.triu(input,diagonal)
input表示一个需要进行上三角矩阵处理的输入矩阵input
diagonal默认为0，默认从主对角线上所有的上三角，diagonal=k表示对角线向上走多少，k为正数向上，k为负数向下

x = torch.randn((4,4))
x_tri = torch.triu(x)
x_tri_1 = torch.triu(x,diagonal=1)
x_tri_2 = torch.triu(x,diagonal=2)
x_tri_f1 = torch.triu(x,diagonal=-1)
x_tri_f2 = torch.triu(x,diagonal=-2)
print(f"x={x}")
print(f"x_tri={x_tri}")
print(f"x_tri_1={x_tri_1}")
print(f"x_tri_2={x_tri_2}")
print(f"x_tri_f1={x_tri_f1}")
print(f"x_tri_f2={x_tri_f2}")

x=tensor([[-0.8635, -0.0673,  0.9718,  0.8746],
          [-1.7199, -1.0076,  0.5058, -0.1469],
          [-0.6094,  1.3910,  0.1160,  0.0928],
          [ 1.9978, -1.6106, -0.0179, -0.2358]])


x_tri=tensor([[-0.8635, -0.0673,  0.9718,  0.8746],
              [ 0.0000, -1.0076,  0.5058, -0.1469],
              [ 0.0000,  0.0000,  0.1160,  0.0928],
              [ 0.0000,  0.0000,  0.0000, -0.2358]])


x_tri_1=tensor([[ 0.0000, -0.0673,  0.9718,  0.8746],
                [ 0.0000,  0.0000,  0.5058, -0.1469],
                [ 0.0000,  0.0000,  0.0000,  0.0928],
                [ 0.0000,  0.0000,  0.0000,  0.0000]])


x_tri_2=tensor([[ 0.0000,  0.0000,  0.9718,  0.8746],
                [ 0.0000,  0.0000,  0.0000, -0.1469],
                [ 0.0000,  0.0000,  0.0000,  0.0000],
                [ 0.0000,  0.0000,  0.0000,  0.0000]])


x_tri_f1=tensor([[-0.8635, -0.0673,  0.9718,  0.8746],
                 [-1.7199, -1.0076,  0.5058, -0.1469],
                 [ 0.0000,  1.3910,  0.1160,  0.0928],
                 [ 0.0000,  0.0000, -0.0179, -0.2358]])


x_tri_f2=tensor([[-0.8635, -0.0673,  0.9718,  0.8746],
                 [-1.7199, -1.0076,  0.5058, -0.1469],
                 [-0.6094,  1.3910,  0.1160,  0.0928],
                 [ 0.0000, -1.6106, -0.0179, -0.2358]])

9. torch.tile

通过重复输入的元素构造一个张量。dims参数指定每个维度的重复次数

import torch

x = torch.Tensor([1,2,3])
# 将输入 x 按行复制到3遍，列复制到4遍
x_dim_3_4 = torch.tile(x,(3,4))

y = torch.tensor([[4,5,6],[7,8,9]])

# 将输入 y 按行复制到2遍，列复制到3遍
y_dim_2_3 = torch.tile(y,(2,3))

print(f"x={x}")
# x=tensor([1., 2., 3.])

print(f"x.shape={x.shape}")
# x.shape=torch.Size([3])

print(f"x_dim_3_4={x_dim_3_4}")
# x_dim_3_4=tensor([[1., 2., 3., 1., 2., 3., 1., 2., 3., 1., 2., 3.],
#         [1., 2., 3., 1., 2., 3., 1., 2., 3., 1., 2., 3.],
#         [1., 2., 3., 1., 2., 3., 1., 2., 3., 1., 2., 3.]])
print(f"x_dim_3_4.shape={x_dim_3_4.shape}")
# x_dim_3_4.shape=torch.Size([3, 12])

print(f"y={y}")
# y=tensor([[4, 5, 6],
#         [7, 8, 9]])
print(f"y.shape={y.shape}")
# y.shape=torch.Size([2, 3])

print(f"y_dim_2_3={y_dim_2_3}")
# y_dim_2_3=tensor([[4, 5, 6, 4, 5, 6, 4, 5, 6],
#         [7, 8, 9, 7, 8, 9, 7, 8, 9],
#         [4, 5, 6, 4, 5, 6, 4, 5, 6],
#         [7, 8, 9, 7, 8, 9, 7, 8, 9]])
print(f"y_dim_2_3.shape={y_dim_2_3.shape}")
# y_dim_2_3.shape=torch.Size([4, 9])

10. torch.flip

作用：将输入张量指定的维度进行倒序处理。

import torch

# 定义输入 x
x = torch.arange(24).reshape((2, 3, 4))
# 将第0维进行倒序
x_0 = torch.flip(x, [0])
# 将第1维进行倒序
x_1 = torch.flip(x, [1])
# 将第2维进行倒序
x_2 = torch.flip(x, [2])
# 将第0，1维同时进行倒序
x_0_1 = torch.flip(x, [0, 1])
print(f"x={x}")
print(f"x_0={x_0}")
print(f"x_1={x_1}")
print(f"x_2={x_2}")
print(f"x_0_1={x_0_1}")
  • 结果
x=tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],

        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]])
x_0=tensor([[[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]],

        [[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]]])
x_1=tensor([[[ 8,  9, 10, 11],
         [ 4,  5,  6,  7],
         [ 0,  1,  2,  3]],

        [[20, 21, 22, 23],
         [16, 17, 18, 19],
         [12, 13, 14, 15]]])
x_2=tensor([[[ 3,  2,  1,  0],
         [ 7,  6,  5,  4],
         [11, 10,  9,  8]],

        [[15, 14, 13, 12],
         [19, 18, 17, 16],
         [23, 22, 21, 20]]])
x_0_1=tensor([[[20, 21, 22, 23],
         [16, 17, 18, 19],
         [12, 13, 14, 15]],

        [[ 8,  9, 10, 11],
         [ 4,  5,  6,  7],
         [ 0,  1,  2,  3]]])

11. torch.chunk

主要作用是将张量分割成指定份数；dim可以指定维度；此函数方便切割张量

# -*- coding: utf-8 -*-
# @Project: zc
# @Author: zc
# @File name: chunk_new_test
# @Create time: 2022/5/3 14:48

import torch

x11 = torch.arange(11)
x12 = torch.arange(12)
x13 = torch.arange(13)

# 将张量切割成6份
# 11/6=1.83  --> n = 2  每2个元素组成一组
# 12/6=2     --> n = 2  每2个元素组成一组
# 13/6=2.16  --> n = 3  每3个元素组成一组
y11 = torch.chunk(x11, 6)
y12 = torch.chunk(x12, 6)
y13 = torch.chunk(x13, 6)

print(f"x11={x11}")
# x11=tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

print(f"x12={x12}")
# x12=tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

print(f"x13={x13}")
# x13=tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])


print(f"y11={y11}")
# y11=(tensor([0, 1]), tensor([2, 3]), tensor([4, 5]), tensor([6, 7]), tensor([8, 9]), tensor([10]))

print(f"y12={y12}")
# y12=(tensor([0, 1]), tensor([2, 3]), tensor([4, 5]), tensor([6, 7]), tensor([8, 9]), tensor([10, 11]))

print(f"y13={y13}")
# y13=(tensor([0, 1, 2]), tensor([3, 4, 5]), tensor([6, 7, 8]), tensor([ 9, 10, 11]), tensor([12]))


x = torch.arange(24).reshape((2,3,4))
print(f"x={x}")
# 将 x 按照第0维分成2份
x0 = torch.chunk(x,2,dim=0)

# 将 x 按照第1维分成2份
x1 = torch.chunk(x,2,dim=1)

# 将 x 按照第2维分成2份
x2 = torch.chunk(x,2,dim=2)

print(f"x0={x0}")
# x0=(tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]]]), tensor([[[12, 13, 14, 15],
#          [16, 17, 18, 19],
#          [20, 21, 22, 23]]]))
print(f"x1={x1}")
# x1=(tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7]],
# 
#         [[12, 13, 14, 15],
#          [16, 17, 18, 19]]]), tensor([[[ 8,  9, 10, 11]],
# 
#         [[20, 21, 22, 23]]]))
print(f"x2={x2}")
# x2=(tensor([[[ 0,  1],
#          [ 4,  5],
#          [ 8,  9]],
# 
#         [[12, 13],
#          [16, 17],
#          [20, 21]]]), tensor([[[ 2,  3],
#          [ 6,  7],
#          [10, 11]],
# 
#         [[14, 15],
#          [18, 19],
#          [22, 23]]]))

12. torch.roll

沿着给定的维滚动张量。移动到最后一个位置以外的元素会在第一个位置重新引入。如果没有指定尺寸，则在滚动前将张量压平，然后恢复到原始形状;相当于按位移动

torch.roll(input, shifts, dims=None) → Tensor
  • input:输入的张量
  • shifts:移动的步数
  • dims:移动的维度
# 创建一个3行4列矩阵
x = torch.arange(12).reshape(3,4)
print(f"x={x}")
# x=tensor([[ 0,  1,  2,  3],
#           [ 4,  5,  6,  7],
#           [ 8,  9, 10, 11]])

# 整体行向下移动一行，最后一行跑到第一行
x_1_d = torch.roll(x, 1, dims=0)

# x_1_d=tensor([[ 8,  9, 10, 11],
#               [ 0,  1,  2,  3],
#               [ 4,  5,  6,  7]])


# 整体行向上移动一行，第一行跑到最后一行
x_1_u = torch.roll(x, -1, dims=0)
# x_1_u=tensor([[ 4,  5,  6,  7],
#               [ 8,  9, 10, 11],
#               [ 0,  1,  2,  3]])

# 整体列向左移动一列，第一列跑到最后一列
x_1_l = torch.roll(x, -1, dims=1)
# x_1_l=tensor([[ 1,  2,  3,  0],
#               [ 5,  6,  7,  4],
#               [ 9, 10, 11,  8]])


# 整体列向有移动一列，最后一列跑到第一列
x_1_r = torch.roll(x, 1, dims=1)
# x_1_r=tensor([[ 3,  0,  1,  2],
#               [ 7,  4,  5,  6],
#               [11,  8,  9, 10]])

print(f"x_1_d={x_1_d}")
print(f"x_1_u={x_1_u}")
print(f"x_1_l={x_1_l}")
print(f"x_1_r={x_1_r}")

13. torch.sum

作用：对输入的张量进行求和，dim可以指定维度进行求和

torch.sum(input, *, dtype=None) → Tensor

import torch

x = torch.arange(24).reshape(2,3,4)

# 按照第0维度进行求和;每一个batch批次求和
# x[0]=[[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7],
#       [ 8,  9, 10, 11]]

# x[1]=[[12, 13, 14, 15],
#       [16, 17, 18, 19],
#       [20, 21, 22, 23]]

# 按照第0维度进行求和，即行与行之间求和
x_sum_0 = torch.sum(x,dim=0)
# x_sum_0=tensor([[12, 14, 16, 18],
#                 [20, 22, 24, 26],
#                 [28, 30, 32, 34]])


# 按照第1维度进行求和,[2,0,4]+[2,1,4]+[2,2,4]
x_sum_1 = torch.sum(x,dim=1)
# x=tensor([[[ 0,  1,  2,  3],
#            [ 4,  5,  6,  7],
#            [ 8,  9, 10, 11]],
#
#           [[12, 13, 14, 15],
#            [16, 17, 18, 19],
#            [20, 21, 22, 23]]])

# x_sum_1=tensor([[12=0+4+8, 15=1+5+9, 18=2+6+10, 21=3+7+11],
#                [48=12+16+20, 51=13+17+21, 54=14+18+22, 57=15+19+23]])

# 按照第2维进行求和，即列与列之间求和
x_sum_2 = torch.sum(x,dim=2)
# x=tensor([[[ 0,  1,  2,  3],
#            [ 4,  5,  6,  7],
#            [ 8,  9, 10, 11]],
#
#           [[12, 13, 14, 15],
#            [16, 17, 18, 19],
#            [20, 21, 22, 23]]])
# x_sum_2=tensor([[ 6=0+1+2+3, 22=4+5+6+7, 38=8+9+10+11],
#                 [54=12+13+14+15, 70=16+17+18+19, 86=20+21+22+23]])

print(f"x={x}")
# x=tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]],
# 
#         [[12, 13, 14, 15],
#          [16, 17, 18, 19],
#          [20, 21, 22, 23]]])
print(f"x.shape={x.shape}")
# x.shape=torch.Size([2, 3, 4])
print(f"x_sum_0={x_sum_0}")
# x_sum_0=tensor([[12, 14, 16, 18],
#         [20, 22, 24, 26],
#         [28, 30, 32, 34]])
print(f"x_sum_0.shape={x_sum_0.shape}")
# x_sum_0.shape=torch.Size([3, 4])
print(f"x_sum_1={x_sum_1}")
# x_sum_1=tensor([[12, 15, 18, 21],
#                 [48, 51, 54, 57]])
print(f"x_sum_1.shape={x_sum_1.shape}")
# x_sum_1.shape=torch.Size([2, 4])
print(f"x_sum_2={x_sum_2}")
# x_sum_2=tensor([[ 6, 22, 38],
#                 [54, 70, 86]])
print(f"x_sum_2.shape={x_sum_2.shape}")
# x_sum_2.shape=torch.Size([2, 3])

14. torch.argmax()

返回输入张量中所有元素最大值的索引;主要做分类用；

import torch 

torch.manual_seed(100)
# 随机生成一个矩阵[2,3,4],里面的值不能超过10
x = torch.randint(10,size=(2,3,4))
# x=tensor([[[0, 2, 5, 9],
#            [5, 1, 2, 8],
#            [8, 0, 4, 3]],
#
#           [[8, 8, 4, 4],
#            [1, 0, 4, 3],
#            [8, 7, 4, 6]]])
# 按照第0维进行比较，批次与批次之间对比;返回值比较大的批次序号
x_0 = torch.argmax(x,dim=0)
# 举例，0<8返回1，2<8返回1，5>4返回0,9>4返回0；
# 所以x_0的第一行返回为[1,1,0,0]

# x_0=tensor([[1, 1, 0, 0],
#             [0, 0, 1, 0],
#             [0, 1, 0, 1]])
# x[0]= [[0, 2, 5, 9],
#        [5, 1, 2, 8],
#        [8, 0, 4, 3]]
# X[1]= [[8, 8, 4, 4],
# 		 [1, 0, 4, 3],
# 		 [8, 7, 4, 6]]


# 按照第1维进行比较，行与行之间对比，返回每个批次中值最大的行号
x_1 = torch.argmax(x,dim=1)
# 举例我们在0,5,8中， 最大的是8，返回序列2；
#        在2,1,0中； 最大的是2，返回序列0;
#        在5,2,4中； 最大的是5，返回序列0;
#        在9,8,3中； 最大的是9，返回序列0;
# 所以x_1的第一行为[2,0,0,0]
# x=tensor([[[0, 2, 5, 9],
#            [5, 1, 2, 8],
#            [8, 0, 4, 3]],
#
#           [[8, 8, 4, 4],
#            [1, 0, 4, 3],
#            [8, 7, 4, 6]]])
# x_1=tensor([[2, 0, 0, 0],
#             [0, 0, 0, 2]])
# 按照第2维进行比较，列与列之间对比，返回每行中每列值最大的列号
x_2 = torch.argmax(x,dim=2)
# 举例：
# 在[0,2,5,9]中，最大的是9，返回序号3
# 在[5,1,2,8]中，最大的是8，返回序号3
# 在[8,0,4,3]中，最大的是8，返回序号0
# 所以x_2中结果为[3,3,0]
# x=tensor([[[0, 2, 5, 9],
#            [5, 1, 2, 8],
#            [8, 0, 4, 3]],
#
#           [[8, 8, 4, 4],
#            [1, 0, 4, 3],
#            [8, 7, 4, 6]]])
# x_2=tensor([[3, 3, 0],
#             [0, 2, 0]])

print(f"x={x}")
# x=tensor([[[0, 2, 5, 9],
#          [5, 1, 2, 8],
#          [8, 0, 4, 3]],
# 
#         [[8, 8, 4, 4],
#          [1, 0, 4, 3],
#          [8, 7, 4, 6]]])
print(f"x.shape={x.shape}")
# x.shape=torch.Size([2, 3, 4])
print(f"x_0={x_0}")
# x_0=tensor([[1, 1, 0, 0],
#             [0, 0, 1, 0],
#             [0, 1, 0, 1]])
print(f"x_0.shape={x_0.shape}")
# x_0.shape=torch.Size([3, 4])
print(f"x_1={x_1}")
# x_1=tensor([[2, 0, 0, 0],
#         [0, 0, 0, 2]])
print(f"x_1.shape={x_1.shape}")
# x_1.shape=torch.Size([2, 4])
print(f"x_2={x_2}")
# x_2=tensor([[3, 3, 0],
#         [0, 2, 0]])
print(f"x_2.shape={x_2.shape}")
# x_2.shape=torch.Size([2, 3])

15. torch.nn.functional.softmax

torch.nn.functional.softmax(input, dim=None, _stacklevel=3, dtype=None)
  • input:输入的张量
  • dim:指定维度
    s o f t m a x ( x i ) = exp ⁡ x i ∑ j exp ⁡ x j softmax(x_i)=\frac{\exp{x_i}}{\sum_j\exp{x_j}} softmax(xi​)=∑j​expxj​expxi​​
import torch
from torch.nn import functional as F

# 随机生成一个张量x
x = torch.randn(3,4)

# 沿着dim=0求概率分布
x_0 = F.softmax(x,dim=0)

# 沿着dim=1求概率分布
x_1 = F.softmax(x,dim=1)

# 沿着dim=0求和，确认是否和为1
x_0_sum = torch.sum(x_0,dim=0)

# 沿着dim=1求和，确认是否和为1
x_1_sum = torch.sum(x_1,dim=1)
print(f"x_0_sum={x_0_sum}")
# x_0_sum=tensor([1., 1., 1., 1.])
print(f"x_1_sum={x_1_sum}")
# x_1_sum=tensor([1., 1., 1.])

# 求和
y_0_sum = torch.sum(torch.exp(x),dim=0,keepdim=True)
y_1_sum = torch.sum(torch.exp(x),dim=1,keepdim=True)

# 按照公式手动计算得到y_0,y_1
y_0 = torch.exp(x)/torch.sum(torch.exp(x),dim=0,keepdim=True)
y_1 = torch.exp(x)/torch.sum(torch.exp(x),dim=1,keepdim=True)

# 比较x_0==y_0,如果flag_0=True表示公式计算和函数计算一致
flag_0 = torch.isclose(x_0,y_0)
# flag_0=tensor([[True, True, True, True],
#         [True, True, True, True],
#         [True, True, True, True]])
# 比较x_1==y_1,如果flag_1=True表示公式计算和函数计算一致
flag_1 = torch.isclose(x_1,y_1)
# flag_1=tensor([[True, True, True, True],
#         [True, True, True, True],
#         [True, True, True, True]])
print(f"flag_0={flag_0}")
print(f"flag_1={flag_1}")
print(f"x={x}")
print(f"x.shape={x.shape}")
print(f"x_0={x_0}")
print(f"x_0.shape={x_0.shape}")
print(f"y_0={y_0}")
print(f"y_0.shape={y_0.shape}")
print(f"y_1={y_1}")
print(f"y_1.shape={y_1.shape}")
print(f"x_1={x_1}")
print(f"x_1.shape={x_1.shape}")
print(f"y_0_sum={y_0_sum}")
print(f"y_0_sum.shape={y_0_sum.shape}")
print(f"y_1_sum={y_1_sum}")
print(f"y_1_sum.shape={y_1_sum.shape}")

16. torch.nn.LSTM & torch.nn.LSTMCELL

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


my_lstm_cell = nn.LSTMCell(input_size=10,hidden_size=20)
input = torch.randn(3,10)
h_0 = torch.randn(3,20)
c_0 = torch.randn(3,20)
h_n1, c_n1 = my_lstm_cell(input, (h_0, c_0))
print(f"h_n1={h_n1}")
print(f"h_n1.shape={h_n1.shape}")
print(f"c_n1={c_n1}")
print(f"c_n1.shape={c_n1.shape}")

my_lstm = nn.LSTM(input_size=4,hidden_size=6)
input = torch.randn(2,3,4)
h_0 = torch.randn(1,3,6)
c_0 = torch.randn(1,3,6)
output,(h_n2,c_n2) = my_lstm(input,(h_0,c_0))
print(f"output={output}")
print(f"output.shape={output.shape}")
print(f"h_n2.shape={h_n2.shape}")
print(f"h_n2.shape={h_n2.shape}")

17. torch.any&torch.all

  • torch.any: 表示的是输入input里面只要含一个True，就返回True；全为False才返回False
  • torch.all:表示的是输入input里面只要含一个False，就返回False；全为True才返回True
import torch

a = torch.Tensor([False,False,False])
b = torch.Tensor([True,False,False])
c = torch.Tensor([True,True,True])

# torch.any 表示的是张量input中只要有一个True就返回True,只有所有为False则返回False

# 全为False，故a_any = False
a_any = torch.any(a)
# 有一个True,故b_any = True
b_any = torch.any(b)
# 全为True，故c_any = True
c_any = torch.any(c)

# torch.all 表示的是张量input中全为True，则返回True，否则返回False
# 因为 a 全为False，故 a_all = False
a_all = torch.all(a)

# 因为 b 只有一个True,故 b_all = False
b_all = torch.all(b)

# 因为 c全为True，故c_all = True
c_all = torch.all(c)


# a=tensor([0., 0., 0.])
# b=tensor([1., 0., 0.])
# c=tensor([1., 1., 1.])
# a_any=False
# b_any=True
# c_any=True
# a_all=False
# b_all=False
# c_all=True

print(f"a={a}")
print(f"b={b}")
print(f"c={c}")
print(f"a_any={a_any}")
print(f"b_any={b_any}")
print(f"c_any={c_any}")
print(f"a_all={a_all}")
print(f"b_all={b_all}")
print(f"c_all={c_all}")

18.torch.stack & torch.cat

  • torch.stack:沿着一个新的维度连接张量序列。
  • torch.cat:沿着指定维度连接张量
  • 区别：stack:产生新的维度，cat不产生新的维度
import torch

x = torch.ones(3,4)
y = torch.zeros(3,4)
xy_cat = torch.cat((x,y))
xy_stack = torch.stack((x,y))
print(f"x={x}")
print(f"y={y}")
print(f"xy_cat={xy_cat}")
print(f"xy_cat.shape={xy_cat.shape}")
print(f"xy_stack={xy_stack}")
print(f"xy_stack.shape={xy_stack.shape}")

x=tensor([[1., 1., 1., 1.],
          [1., 1., 1., 1.],
          [1., 1., 1., 1.]])
y=tensor([[0., 0., 0., 0.],
          [0., 0., 0., 0.],
          [0., 0., 0., 0.]])
xy_cat=tensor([[1., 1., 1., 1.],
               [1., 1., 1., 1.],
               [1., 1., 1., 1.],
               [0., 0., 0., 0.],
               [0., 0., 0., 0.],
               [0., 0., 0., 0.]])
# torch.cat不产生新的维度，是在原来的维度上进行叠加
xy_cat.shape=torch.Size([6, 4])
xy_stack=tensor([[[1., 1., 1., 1.],
                  [1., 1., 1., 1.],
                  [1., 1., 1., 1.]],

                 [[0., 0., 0., 0.],
                  [0., 0., 0., 0.],
                  [0., 0., 0., 0.]]])
# torch.stack在一个新的维度上进行叠加
xy_stack.shape=torch.Size([2, 3, 4])
取个名字真难呐
关注
专栏目录
使用PyTorch进行Pygame开发实践
AI天才研究院
08-08 2110
Pygame 是Python中用于制作游戏、交互式艺术或多媒体应用的一款免费开源软件包。作为一种跨平台解决方案，它支持Windows、Linux和Mac系统，并且支持C、C++、Python语言及其扩展版本。Pygame的简单易用特性使得游戏编程变得十分容易。本文将基于Pygame和PyTorch深入探讨如何在游戏项目中集成PyTorch深度学习框架，并演示如何使用Pytorch实现一个简单的基于Pygame的游戏项目——Flappy Bird。
深度学习框架PyTorch原理与实践
AI天才研究院
09-19 1923
本文的读者需要具备一定机器学习或深度学习基础知识，熟悉Python编程语言。读者应该熟练掌握常用的数学运算、线性代数、微积分和概率论。Facebook AI Research团队于2017年发布了基于Python的开源深度学习框架PyTorch。PyTorch由两部分组成，第一部分是高效的神经网络运算库，第二部分是用于构建、训练和评估神经网络的工具包。PyTorch提供了一个灵活而优雅的接口，使得构建、训练和测试神经网络变得容易。
pytorch中torch.masked_select()总结
m0_46483236的博客
03-29 5900
官方文档： 实例
Pytorch - masked_fill方法参数详解与使用
HW140701的博客
08-15 6788
输入的mask需要与当前的基础Tensor的形状一致。将mask中为True的元素对应的基础Tensor的元素设置为值value。返回填充后的Tensor。
pytorch中矩阵计算的一些方法|CSDN创作打卡
m0_61686427的博客
01-18 2478
李沐老师线性代数那一章的总结一、平均数二、广播机制三、某个轴计算A的累加求和四、求矩阵点积五、求一个矩阵和一个向量的乘积六、求矩阵的乘积七、求向量范数八、求矩阵的范数 一、平均数 1.先生成A 2.进行平均数的运算 Mean函数就是一个求平均值的函数，也可以表示为A.sum()/A.numel()，numel函数求得A中元素的个数。 此外还可以单独对某一个维度求平均数，也是有两种方法，其中shape[0]是指第一个维度元素的个数（形状） 二、广播机制 如果用了axis之后，那个被求和的维度就没有了。但是想利
PyTorch基础（20）-- torch.gt() / torch.ge() / torch.le() / torch.lt()方法
最新发布
奋斗の博客
03-08 1214
嗯……最近遇到的奇奇怪怪的方法很多了，学无止境啊！学不完啊，根本学不完！torch.gt()、torch.ge()、torch.le()和torch.lt()方法，由于这四个方法很相似，所以放到一块解析了！函数作用inputotherinput≥otherinput≤otherinputother。
torch 函数整理
ningchewinbell的博客
06-03 7381
torch.nn.Conv2d torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True) 卷积操作，输入矩阵大小 (N, Cin, H, W)，输入矩阵大小N, Cout, Hout, Wout) 参数说明 in_channels ...
pytorch1.5.1官方英文文档PythonAPI和Library(包含书签，吐血整理)
07-19
从整体上来看，PyTorch 1.5.1的官方英文API和库文档是一份全面的参考资料，为深度学习领域的研究者和工程师提供了详尽的技术细节和实践指南。通过这份文档，开发者能够更有效率地利用PyTorch强大的功能和灵活的API来...
深度学习框架PyTorch入门与实践：第一章 PyTorch简介
u011436316的博客
09-13 7510
本章为PyTorch简介。主要内容包括：PyTorch的诞生过程，常见主流深度学习框架的优劣，PyTorch相比这些框架的优势等。
《PyTorch深度学习实践》学习笔记(1)
t28383993的博客
01-24 1737
深度学习，刘二大人
torch---pytorch常用函数（持续更新中.......）
热门推荐
qq_24407657的博客
08-19 1万+
随机抽样类函数 1.torch.manual_seed(seed) 设定生成随机数的种子，并返回一个torch._C.Generator对象 参数：seed(int or long)种子 2.torch.initial_seed() 返回生成随机数的原始种子（pathon long） 3.torch.get_rng_state() 返回随机生成器状态（Byte Tensor） 4....
pytorch笔记：allclose，isclose，eq，equal
qq_40206371的博客
11-02 2261
是一个PyTorch函数，用于检查两个张量是否在某个容忍度范围内近似相等otherrtolatolequal_nan。
Pytorch\张量的创建
linchao0711的博客
04-03 2263
张量的创建 torch.tensor() 从data创建一个张量 data:数据，可以是list、numpy dtype : 数据类型，默认与data的一致 device : 所在设备, cuda/cpu requires_grad：是否需要梯度操作 pin_memory：是否存于锁页内存 torch.zeros() 根据size创建全为0的张量 ...
pytorch masked_fill
真的是个瘦子
03-26 1万+
import torch.nn.functional as F import numpy as np a = torch.Tensor([1,2,3,4]) a = a.masked_fill(mask = torch.ByteTensor([1,1,0,0]), value=-np.inf) print(a) b = F.softmax(a) print(b) tensor([-inf,...
.ge()函数
JannyYang的博客
09-09 4047
import operator #首先要导入运算符模块 operator.gt(1,2) #greater than（大于） operator.ge(1,2) #greater and equal（大于等于） operator.eq(1,2) #equal（等于） operator.le(1,2) #less and equal（小于等于） op...
python3 gt,ge,eq,le,lt函数
高压锅博客
08-04 2404
1. 比较大小的函数 Python3中已经不能使用cmp()函数了，被如下五个函数替代: import operator #首先要导入运算符模块 operator.gt(1,2) #意思是greater than（大于） operator.ge(1,2) #意思是greater and equal（大于等于） operator.eq(1,2) #意思是equal（等于） operator.le(1,2) #意思是less and equal（小于等于） o
pytorch（三）——Tensor张量的运算
北落师门XY的博客
03-14 3749
注：以下均基于导入库 import torch 构造方法 常用函数 .reshape()#变形 .size()#返回大小 .dim()#返回维度，即size返回的数据条目个数 .numel()#返回元素个数，即size返回条目之积 .dtype#查看元素类型，int默认torch.int64，bool默认torch.uint8...
input之key（一）
s_jason的博客
06-13 5145
今天在android上添加了一个按键，这个按键是我随便找了一个gpio来做的，但是怎么添加都不成功，添加按键前后做了一下对比： 　　添加前： 　　（１）dtsi中： 　　tlmm_gpio_key {   28             qcom,pins = , , ;   27             qcom,pin-func = ;   26             qcom,n
Python numpy.round(0.5) 的一个问题
YYyyy
01-18 1万+
  在完成第三周的作业时候，并没有像第二周一样直接暴力的使用if else实现最后的预测结果部分的判断，而是使用了np.round()，于是测试时候出现了一个问题。 输入： import numpy as np print(np.round(0.5)) print(np.round(1.5)) 输出： 0.0 2.0   很奇怪啊，明明是四舍五入，但是输出了0，在文档中给出了相关的回答： p...
pytorch教程--API接口学习
人生百态361
07-08 1646
函数式API和类API 网络层 全连接层 torch.nn.functional.linear torch.nn.linear Dropout torch.nn.functional.dropout torch.nn.dropout 批标准化层 torch.nn.functional.batch_norm torch.nn.BatchNorm2d 卷积层 torch.nn.functional.conv2d torch.nn.ConV2d 池化层 torch.nn.functional.max_pool2d
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值