Pytorch创建张量

文章目录

    • 1.torch.from_numpy()
    • 2. torch.zeros()
    • 3. torch.ones()
    • 4. torch.arange()
    • 5. torch.linspace()
    • 6. torch.logspace()
    • 7. torch.eye()
    • 8. torch.empty()
    • 9. torch.full()
    • 10. torch.complex()
    • 10. torch.rand()
    • 10. torch.randint()
    • 11. torch.randn
    • 12. torch.normal()
    • 13. torch.uniform()
    • 14. torch.as_tensor()
    • 15. torch.sparse_coo_tensor()
    • 16. torch.bernoulli()
    • 17. torch.multinomial()
    • 17. torch.poisson()
    • 18. torch.randperm()


在这里插入图片描述


1.torch.from_numpy()

torch.from_numpy(ndarray)
"""
ndarray:NumPy 数组对象,用于创建对应的张量。
"""
import numpy as np
import torch# 创建一个 NumPy 数组
numpy_array = np.array([1, 2, 3, 4, 5])# 使用 torch.from_numpy() 创建张量
tensor = torch.from_numpy(numpy_array)print(tensor)  # 输出: tensor([1, 2, 3, 4, 5])
print(type(tensor))  # 输出: <class 'torch.Tensor'># 修改张量
tensor[0] = 10print(tensor)  # 输出: tensor([10,  2,  3,  4,  5])# 修改原始 NumPy 数组
print(numpy_array)  # 输出: [10  2  3  4  5]
"""
在 NumPy 中,默认情况下,当打印一个一维数组时,元素之间是不带逗号分隔的。
这是 NumPy 打印数组的默认行为。
如果希望在打印 NumPy 数组时显示逗号分隔的元素可以
使用 numpy.set_printoptions() 方法来更改打印选项。
"""

2. torch.zeros()

  torch.zeros() 函数是 PyTorch 中用于创建元素全为零的张量的函数。

torch.zeros(*size, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
*size:表示张量的形状,可以是一个整数或一个元组。
dtype:表示张量的数据类型,默认为 torch.float32。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的零张量
zeros_tensor = torch.zeros(2, 3)
print(zeros_tensor)
# 输出:
# tensor([[0., 0., 0.],
#         [0., 0., 0.]])# 创建一个形状为 (3, 4, 2) 的零张量,数据类型为整数
zeros_int_tensor = torch.zeros((3, 4, 2), dtype=torch.int)
print(zeros_int_tensor)
# 输出:
# tensor([[[0, 0],
#          [0, 0],
#          [0, 0],
#          [0, 0]],
#
#         [[0, 0],
#          [0, 0],
#          [0, 0],
#          [0, 0]],
#
#         [[0, 0],
#          [0, 0],
#          [0, 0],
#          [0, 0]]], dtype=torch.int32)

3. torch.ones()

  torch.ones() 函数是 PyTorch 中用于创建元素全为一的张量的函数。

torch.ones(*size, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
*size:表示张量的形状,可以是一个整数或一个元组。
dtype:表示张量的数据类型,默认为 torch.float32。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的全为一的张量
ones_tensor = torch.ones(2, 3)
print(ones_tensor)
# 输出:
# tensor([[1., 1., 1.],
#         [1., 1., 1.]])# 创建一个形状为 (3, 4, 2) 的全为一的张量,数据类型为整数
ones_int_tensor = torch.ones((3, 4, 2), dtype=torch.int)
print(ones_int_tensor)
# 输出:
# tensor([[[1, 1],
#          [1, 1],
#          [1, 1],
#          [1, 1]],
#
#         [[1, 1],
#          [1, 1],
#          [1, 1],
#          [1, 1]],
#
#         [[1, 1],
#          [1, 1],
#          [1, 1],
#          [1, 1]]], dtype=torch.int32)

4. torch.arange()

  PyTorch 提供了一个名为 torch.arange() 的函数,用于创建具有指定范围内连续值的张量。

torch.arange(start, end=None, step=1, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
start:起始值(包含)。
end:结束值(不包含)。
step:步长,默认为 1。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个从 0 到 9 的张量
tensor = torch.arange(10)
print(tensor)
# 输出: tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])# 创建一个从 5 到 15 步长为 2 的张量
tensor = torch.arange(5, 15, 2)
print(tensor)
# 输出: tensor([ 5,  7,  9, 11, 13])

5. torch.linspace()

torch.linspace() 是 PyTorch 中用于创建一维等间隔数值的张量的函数

torch.linspace(start, end, steps=100, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
start:起始值。
end:结束值。
steps:生成的数值的数量,默认为 100。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个从 0 到 1(包含 1)的等间隔张量,共有 5 个数值
tensor = torch.linspace(0, 1, 5)
print(tensor)
# 输出: tensor([0.0000, 0.2500, 0.5000, 0.7500, 1.0000])# 创建一个从 10 到 20(包含 20)的等间隔张量,共有 11 个数值,数据类型为整数
tensor = torch.linspace(10, 20, 11, dtype=torch.int)
print(tensor)
# 输出: tensor([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], dtype=torch.int32)

6. torch.logspace()

torch.logspace(start, end, steps=100, base=10.0, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:start:起始指数。
end:结束指数。
steps:生成的数值的数量,默认为 100。
base:对数的底数,默认为 10.0。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个在 1e-2 到 1e2 之间的对数刻度张量,共有 5 个数值
tensor = torch.logspace(start=-2, end=2, steps=5)
print(tensor)
# 输出: tensor([  0.0100,   0.1000,   1.0000,  10.0000, 100.0000])# 创建一个在 1 到 10^3 之间的以 2 为底的对数刻度张量,共有 4 个数值
tensor = torch.logspace(start=0, end=3, steps=4, base=2)
print(tensor)
# 输出: tensor([ 1.0000,  2.0000,  4.0000,  8.0000])

7. torch.eye()

 PyTorch 提供了一个名为 torch.eye() 的函数,用于创建单位矩阵的张量。

torch.eye(n, m=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:n:生成的单位矩阵的行数。
m:生成的单位矩阵的列数。如果未指定,则默认为 n,即生成一个 n x n 的方阵。
out:输出张量的可选位置。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个 3x3 的单位矩阵
eye_tensor = torch.eye(3)
print(eye_tensor)
# 输出:
# tensor([[1., 0., 0.],
#         [0., 1., 0.],
#         [0., 0., 1.]])# 创建一个 4x4 的单位矩阵,数据类型为整数
eye_int_tensor = torch.eye(4, dtype=torch.int)
print(eye_int_tensor)
# 输出:
# tensor([[1, 0, 0, 0],
#         [0, 1, 0, 0],
#         [0, 0, 1, 0],
#         [0, 0, 0, 1]], dtype=torch.int32)

8. torch.empty()

torch.empty() 是 PyTorch 中用于创建一个未初始化的张量(tensor)的函数。

torch.empty(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:*size:表示张量的形状,可以是一个整数或一个元组。
out:输出张量的可选位置。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的未初始化张量
empty_tensor = torch.empty(2, 3)
print(empty_tensor)
# 输出:
# tensor([[1.8751e+34, 1.8788e+31, 3.0881e-41],
#         [0.0000e+00, 0.0000e+00, 0.0000e+00]])# 创建一个形状为 (3, 4, 2) 的未初始化张量,数据类型为整数
empty_int_tensor = torch.empty((3, 4, 2), dtype=torch.int)
print(empty_int_tensor)
# 输出:
# tensor([[[  875812,   875812],
#          [  875812,   875812],
#          [  875812,   875812],
#          [  875812,   875812]],
#
#         [[  875812,   875812],
#          [  875812,   875812],
#          [  875812,   875812],
#          [  875812,   875812]],
#
#         [[  875812,   875812],
#          [  875812,   875812],
#          [  875812,   875812],
#          [  875812,   875812]]], dtype=torch.int32)

9. torch.full()

torch.full() 是 PyTorch 中用于创建指定形状和值的张量的函数。

torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
size:表示张量的形状,可以是一个整数或一个元组。
fill_value:表示要填充的值。
out:输出张量的可选位置。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的张量,所有元素值均为 5.0
full_tensor = torch.full((2, 3), 5.0)
print(full_tensor)
# 输出:
# tensor([[5., 5., 5.],
#         [5., 5., 5.]])# 创建一个形状为 (3, 2) 的张量,所有元素值均为 -1,数据类型为整数
full_int_tensor = torch.full((3, 2), -1, dtype=torch.int)
print(full_int_tensor)
# 输出:
# tensor([[-1, -1],
#         [-1, -1],
#         [-1, -1]], dtype=torch.int32)

10. torch.complex()

torch.complex() 是 PyTorch 中用于创建复数张量的函数。

torch.complex(real, imag)
参数说明:
real:实部的张量。
imag:虚部的张量。
import torch# 创建实部和虚部的张量
real = torch.tensor([1.0, 2.0])
imag = torch.tensor([0.5, -0.5])# 创建复数张量
complex_tensor = torch.complex(real, imag)print(complex_tensor)
# 输出:
# tensor([1.+0.5000j, 2.-0.5000j])

10. torch.rand()

torch.rand() 是 PyTorch 中用于创建具有随机值的张量的函数。

torch.rand(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
*size:表示张量的形状,可以是一个整数或一个元组。
out:输出张量的可选位置。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的随机值张量
rand_tensor = torch.rand(2, 3)
print(rand_tensor)
# 输出:
# tensor([[0.9184, 0.1503, 0.7769],
#         [0.8832, 0.6201, 0.0705]])# 创建一个形状为 (3, 4, 2) 的随机值张量,数据类型为整数
rand_int_tensor = torch.rand((3, 4, 2), dtype=torch.int)
print(rand_int_tensor)
# 输出:
# tensor([[[0, 0],
#          [0, 0],
#          [0, 0],
#          [0, 0]],
#
#         [[0, 0],
#          [0, 0],
#          [0, 0],
#          [0, 0]],
#
#         [[0, 0],
#          [0, 0],
#          [0, 0],
#          [0, 0]]], dtype=torch.int32)

10. torch.randint()

torch.randint() 是 PyTorch 中用于创建具有随机整数值的张量的函数。

torch.randint(low, high, size, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:high:表示随机整数范围的上界(不包含)。
low:可选参数,表示随机整数范围的下界(包含)。如果未提供 low 参数,则默认为 0。
size:表示张量的形状,可以是一个整数或一个元组。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的随机整数张量,值范围为 [0, 10)
rand_int_tensor = torch.randint(10, (2, 3))
print(rand_int_tensor)
# 输出:
# tensor([[9, 2, 8],
#         [6, 1, 0]])# 创建一个形状为 (3, 4, 2) 的随机整数张量,值范围为 [1, 6)
rand_int_tensor2 = torch.randint(1, 6, (3, 4, 2))
print(rand_int_tensor2)
# 输出:
# tensor([[[3, 4],
#          [4, 5],
#          [2, 2],
#          [5, 1]],
#
#         [[1, 5],
#          [3, 4],
#          [5, 4],
#          [4, 3]],
#
#         [[3, 5],
#          [4, 4],
#          [3, 2],
#          [2, 4]]])# 创建一个形状为 (3,) 的随机整数张量,值范围为 [-5, 5]
rand_int_tensor3 = torch.randint(-5, 6, (3,))
print(rand_int_tensor3)
# 输出:
# tensor([-1,  4,  5])

11. torch.randn

torch.randn() 是 PyTorch 中用于创建具有正态分布(高斯分布)随机值的张量的函数。

torch.randn(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
*size:表示张量的形状,可以是一个整数或一个元组。
out:输出张量的可选位置。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的正态分布随机值张量
rand_tensor = torch.randn(2, 3)
print(rand_tensor)
# 输出:
# tensor([[ 0.1768, -0.1565, -0.3723],
#         [ 0.1222,  0.0453, -0.6545]])# 创建一个形状为 (3, 4, 2) 的正态分布随机值张量,数据类型为整数
rand_int_tensor = torch.randn((3, 4, 2), dtype=torch.int)
print(rand_int_tensor)
# 输出:
# tensor([[[ 1,  0],
#          [-1, -1],
#          [-1,  0],
#          [-1,  1]],
#
#         [[ 0, -1],
#          [-1, -1],
#          [ 0,  1],
#          [ 0,  1]],
#
#         [[ 0,  0],
#          [-1,  0],
#          [ 0,  0],
#          [ 0,  0]]], dtype=torch.int32)

12. torch.normal()

torch.normal() 是 PyTorch 中用于创建具有指定均值和标准差的正态分布随机值的张量的函数。

torch.normal(mean, std, size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
mean:表示正态分布的均值。
std:表示正态分布的标准差。
size:表示张量的形状,可以是一个整数或一个元组。
out:输出张量的可选位置。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的正态分布随机值张量,均值为 0,标准差为 1
rand_tensor = torch.normal(0.0, 1.0, (2, 3))
print(rand_tensor)
# 输出:
# tensor([[ 0.2025, -1.2349, -0.8624],
#         [ 0.5945,  0.4696, -0.9300]])# 创建一个形状为 (3, 4, 2) 的正态分布随机值张量,均值为 2,标准差为 0.5
rand_tensor2 = torch.normal(2.0, 0.5, (3, 4, 2))
print(rand_tensor2)
# 输出:
# tensor([[[ 1.7426,  2.8180],
#          [ 2.0582,  2.4961],
#          [ 2.4627,  2.1690],
#          [ 2.5418,  1.4430]],
#
#         [[ 1.6425,  1.7197],
#          [ 1.7202,  2.2826],
#          [ 2.1842,  2.1941],
#          [ 2.4640,  1.9483]],
#
#         [[ 1.6387,  2.2361],
#          [ 2.2822,  2.1503],
#          [ 2.0832,  1.5682],
#          [ 2.8316,  2.3017]]])

13. torch.uniform()

torch.uniform() 是 PyTorch 中用于创建具有均匀分布随机值的张量的函数。

torch.uniform(from, to, size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
"""
参数说明:
from:表示均匀分布的下界(包含)。
to:表示均匀分布的上界(不包含)。
size:表示张量的形状,可以是一个整数或一个元组。
out:输出张量的可选位置。
dtype:表示张量的数据类型,默认为 None,即自动推断。
layout:表示张量的布局,默认为 torch.strided。
device:表示张量所在的设备,默认为使用当前设备。
requires_grad:表示是否需要计算梯度,默认为 False。
"""
import torch# 创建一个形状为 (2, 3) 的均匀分布随机值张量,范围为 [0, 1)
rand_tensor = torch.uniform(0.0, 1.0, (2, 3))
print(rand_tensor)
# 输出:
# tensor([[0.6585, 0.6943, 0.3527],
#         [0.5127, 0.9489, 0.2360]])# 创建一个形状为 (3, 4, 2) 的均匀分布随机值张量,范围为 [-1, 1)
rand_tensor2 = torch.uniform(-1.0, 1.0, (3, 4, 2))
print(rand_tensor2)
# 输出:
# tensor([[[ 0.4801,  0.7084],
#          [-0.9697, -0.7110],
#          [ 0.1171,  0.4388],
#          [ 0.0897,  0.0358]],
#
#         [[ 0.1239, -0.1015],
#          [ 0.3444,  0.3462],
#          [-0.2054,  0.0474],
#          [-0.3595,  0.5682]],
#
#         [[-0.9373,  0.5579],
#          [ 0.6187, -0.1847],
#          [ 0.3249, -0.0422],
#          [-0.1907,  0.3521]]])

14. torch.as_tensor()

torch.as_tensor() 是 PyTorch 中的一个函数,用于将输入数据转换为张量。

torch.as_tensor(data, dtype=None, device=None) -> Tensor
"""
data:输入数据,可以是 Python 列表、NumPy 数组、标量或其他支持的数据类型。
dtype:可选参数,指定输出张量的数据类型。如果未提供,则会尝试从输入数据中推断数据类型。
device:可选参数,指定输出张量所在的设备。如果未提供,则使用默认设备。
"""

torch.as_tensor() 函数接受输入数据并返回一个张量。它具有以下行为:

  • 如果输入数据已经是 Tensor 类型,它将返回同一张量,不进行复制。
  • 如果输入数据是一个支持数组协议的对象(如 NumPy 数组),它将使用共享内存创建一个张量,而不进行数据复制。
  • 如果输入数据是一个 Python 列表或标量,它将创建一个新的张量,并将数据复制到该张量中。
import torch
import numpy as np# 从 Python 列表创建张量
data_list = [1, 2, 3, 4, 5]
tensor_list = torch.as_tensor(data_list)
print(tensor_list)# 从 NumPy 数组创建张量
data_np = np.array([1, 2, 3, 4, 5])
tensor_np = torch.as_tensor(data_np)
print(tensor_np)# 从标量创建张量
data_scalar = 3.14
tensor_scalar = torch.as_tensor(data_scalar)
print(tensor_scalar)
tensor([1, 2, 3, 4, 5])
tensor([1, 2, 3, 4, 5])
tensor(3.1400)

15. torch.sparse_coo_tensor()

  torch.sparse_coo_tensor() 是 PyTorch 中用于创建稀疏张量的函数。稀疏张量是一种优化表示稀疏数据的数据结构,其中只有部分元素非零。

torch.sparse_coo_tensor(indices, values, size=None, dtype=None, device=None, requires_grad=False) -> Tensor
"""
indices:一个包含非零元素索引的张量,形状为 (N, D),其中 N 是非零元素的数量,D 是张量的维度。
values:一个包含非零元素的值的张量,形状为 (N,)。
size:可选参数,指定稀疏张量的形状。如果未提供,则根据索引中的最大值自动推断形状。
dtype:可选参数,指定稀疏张量的数据类型。如果未提供,则根据输入值的数据类型自动推断。
device:可选参数,指定稀疏张量所在的设备。如果未提供,则使用默认设备。
requires_grad:可选参数,指定是否需要计算梯度。默认为 False。
"""
import torch# Create sparse tensor
indices = torch.tensor([[0, 1, 2], [1, 2, 0]])
values = torch.tensor([1.0, 2.0, 3.0])
size = (3, 3)sparse_tensor = torch.sparse_coo_tensor(indices, values, size)print(sparse_tensor)

16. torch.bernoulli()

torch.bernoulli() 是 PyTorch 中用于生成服从伯努利分布的张量的函数。伯努利分布是一种离散概率分布,它的取值只有两种可能,通常被表示为成功(取值为 1)和失败(取值为 0)。

torch.bernoulli(input, *, generator=None, out=None)
"""
input:一个张量,指定了伯努利分布的概率参数。input 中的每个元素都表示对应位置上成功的概率,取值范围为 [0, 1]。
generator:可选参数,一个随机数生成器对象,用于生成随机数。如果未提供,将使用默认的全局随机数生成器。
out:可选参数,用于指定输出张量的位置。
"""
import torch# 生成服从伯努利分布的张量
probabilities = torch.tensor([0.3, 0.6, 0.8])
result = torch.bernoulli(probabilities)print(result)
tensor([0., 1., 1.])

17. torch.multinomial()

torch.multinomial()是PyTorch中用于从多项分布中生成随机样本的函数。多项式分布是一种常见的概率分布,它描述了具有多个离散可能结果的试验的概率分布。

torch.multinomial(input, num_samples, replacement=False, generator=None, out=None)
"""
input:一个张量,表示每个类别的概率分布。input的形状可以是(N, K),其中N是样本数,K是类别数,或者可以是一个形状为(K,)的一维张量,其中K是类别数。
num_samples:要生成的样本数。
replacement:一个布尔值,指定是否可以有重复的样本。如果为True,则允许有重复样本;如果为False,则不允许有重复样本。
generator:可选参数,一个随机数生成器对象,用于生成随机数。如果未提供,将使用默认的全局随机数生成器。
out:可选参数,用于指定输出张量的位置。
"""
import torch# 从多项分布中生成随机样本
probabilities = torch.tensor([0.2, 0.3, 0.5])
num_samples = 4samples = torch.multinomial(probabilities, num_samples, replacement=True)print(samples)
tensor([1, 0, 1, 0])

17. torch.poisson()

torch.poisson() 是 PyTorch 中用于生成服从泊松分布的张量的函数。泊松分布是一种离散概率分布,用于描述在一定时间或空间间隔内,事件发生的次数的概率分布。

torch.poisson(input, generator=None, out=None)
"""
input:一个张量,指定了泊松分布的概率参数。input 中的每个元素都表示对应位置上的平均事件发生次数。
generator:可选参数,一个随机数生成器对象,用于生成随机数。如果未提供,将使用默认的全局随机数生成器。
out:可选参数,用于指定输出张量的位置。
"""
import torch# 生成服从泊松分布的张量
rate = torch.tensor([1.0, 2.0, 3.0])
result = torch.poisson(rate)print(result)
tensor([1., 5., 3.])

18. torch.randperm()

torch.randperm() 是 PyTorch 中用于生成随机排列的函数。它返回一个从 0 到 n-1 的整数序列的随机排列,其中 n 是输入的参数。

torch.randperm(n, generator=None, out=None, dtype=torch.int64)
"""
n:一个非负整数,用于确定生成的随机排列的长度。
generator:可选参数,一个随机数生成器对象,用于生成随机数。如果未提供,将使用默认的全局随机数生成器。
out:可选参数,用于指定输出张量的位置。
dtype:可选参数,输出张量的数据类型,默认为 torch.int64。
"""
import torch# 生成一个随机排列的整数序列
n = 5
perm = torch.randperm(n)print(perm)
# tensor([2, 1, 3, 0, 4])

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/20630.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

[数据集][目标检测]剪刀石头布检测数据集VOC+YOLO格式1973张3类别

数据集格式&#xff1a;Pascal VOC格式YOLO格式(不包含分割路径的txt文件&#xff0c;仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)&#xff1a;1973 标注数量(xml文件个数)&#xff1a;1973 标注数量(txt文件个数)&#xff1a;1973 标注…

Docker 简介和安装

目录 Docker 是什么 跟普通虚拟机的对比 打包、分发、部署 Docker 部署的优势 Docker 通常用来做什么 重要概念&#xff1a;镜像、容器 安装 镜像加速源 Docker 是什么 Docker 是一个应用打包、分发、部署的工具 你也可以把它理解为一个轻量的虚拟机&#xff0c;它只虚…

SAP揭秘者- SAP PP模块日常常见运维问题之工单入库失败原因分析及快速处理

文章摘要&#xff1a; 无论您是负责SAP实施项目还是负责SAP运维项目&#xff0c;当用户发现有SAP PP模块的各种异常问题的时都需要作为SAP PP顾问的您快速地理解用户提交的问题&#xff0c;并快速地解决这些问题&#xff0c; 上篇文章跟大家聊了基本单位维护错了怎么修改的解决…

ARC学习(2)基本编程模型认识(二)

笔者继续来学习一下arc的编程模型的寄存器信息。 1、core寄存器深入 参数寄存器&#xff1a;r0-r7&#xff0c;8个参数&#xff0c;暂存器&#xff1a;r10-r15保存寄存器&#xff1a;r16-r25 调用函数需要保存的寄存器指针寄存器&#xff1a;gp&#xff08;全局指针&#xff09…

functional函数对象库学习

类模板 std::function 是一种通用多态函数包装器。std::function 的实例能存储、复制及调用任何可复制构造 (CopyConstructible) 的可调用 (Callable) 目标——函数&#xff08;通过其指针&#xff09;、lambda 表达式、bind 表达式或其他函数对象&#xff0c;以及成员函数指针…

FPGA基于DE2-115开发板驱动HC_SR04超声波测距模块|集成蜂鸣器,led和vga提示功能

文章目录 前言一、实验原理二、Verilog文件2.1 时钟分频2.2 超声波测距2.3 超声波驱动 三、实现过程3.1 模块说明3.2 引脚分配 三、演示视频总结参考 前言 环境 硬件 DE2-115 HC-SR04超声波传感器 软件 Quartus 18.1 目标结果 使用DE2-115开发板驱动HC-SR04模块&#xff0…

Windows 下 PostgreSQL 图形化界面安装、配置详解

相信大家对PostgreSQL都不陌生吧&#xff0c;自从MySQL被Oracle所控制后&#xff0c;PostgreSQL就成为了国内去O的首选数据库了&#xff0c;并且PostgreSQL目前不受任何商业公司控制&#xff0c;所以国内很多厂商都是基于PostgreSQL做二次开发来实现数据库自主可控的目标(国内很…

简单模拟实现shell(Linux)

目录​​​​​​​ 前言 展示效果 实现代码 前言 该代码模拟了shell的实现&#xff0c;也就是解析类似于“ls -a -l"的命令&#xff0c;当我们启动我们自己写的shell的可执行程序时&#xff0c;我们输入"ls"的命令&#xff0c;也可以展示出在shell中输入&…

学习笔记——网络参考模型——TCP/IP模型(物理层)

一、TCP/IP模型-物理层 1、数据传输(交换)的形式 (1)电路交换 特点&#xff1a;通信双方独占通信链路。 优点&#xff1a;数据传输时延小&#xff0c;适用于实时通信&#xff1b;数据按序发送&#xff0c;不存在失序问题&#xff1b;适合模拟信号和数字信号传输。 缺点&am…

【前缀和】42. 接雨水

本文涉及知识点 C算法&#xff1a;前缀和、前缀乘积、前缀异或的原理、源码及测试用例 包括课程视频 LeetCode42. 接雨水 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图&#xff0c;计算按此排列的柱子&#xff0c;下雨之后能接多少雨水。 示例 1&#xff1a; 输入&am…

IDEA+MyBatisX根据mapper方法自动添加注解和生成xml方法结构

前提&#xff1a;确保IDEA已安装并启用了MyBatisX插件 在service层写dao或mapper的方法结构&#xff0c;反向生成dao层方法声明&#xff0c;如下&#xff1a; void updateStock(Long skuId, Long wareId, Integer skuNum); 由于该方法传递多个参数&#xff0c;为了让MyBatis识…

心链6----开发主页以及后端数据插入(多线程并发)定时任务

心链 — 伙伴匹配系统 开发主页 信息搜索页修改 主页开发&#xff08;直接list用户&#xff09; 在后端controller层编写接口去实现显示推荐页面的功能 /*** 推荐页面* param request* return*/GetMapping("/recommend")public BaseResponse<List<User>&…

Go-知识并发控制WaitGroup

Go-知识并发控制WaitGroup 1. 认识 WaitGroup2. 基本原理2.1 信号量2.2 数据结构2.3 Add2.4 Wait2.5 Done 3. 小例子3.1 主协程等待子协程执行完成3.2 子协程等待主协程信号3.3 GetFirst 4. 总结 gitio: https://a18792721831.github.io/ 1. 认识 WaitGroup WaitGroup 是Go 应…

公网IP地址如何查询?

公网IP地址是指在互联网中可以被全球范围内的设备访问的IP地址。在网络通信中&#xff0c;公网IP地址扮演着重要的角色&#xff0c;它可以标识设备在互联网中的位置。查询公网IP地址是一种常见的网络管理需求&#xff0c;因为它能够提供网络设备的准确位置信息&#xff0c;方便…

AI 绘画爆火背后:扩散模型原理及实现

节前&#xff0c;我们星球组织了一场算法岗技术&面试讨论会&#xff0c;邀请了一些互联网大厂朋友、参加社招和校招面试的同学。 针对算法岗技术趋势、大模型落地项目经验分享、新手如何入门算法岗、该如何准备、面试常考点分享等热门话题进行了深入的讨论。 合集&#x…

Java进阶学习笔记34——Arrays类

Arrays&#xff1a; 用来操作数组的工具类。 解释说明&#xff1a; 只要知道代码这么写就可以了。 package cn.ensource.d5_arrays;import java.util.Arrays; import java.util.function.IntToDoubleFunction;public class ArraysTest1 {public static void main(String[] arg…

LTspice仿真中设置电阻随时间变化的方法

背景&#xff1a; 笔者找了很多资料都没有看到如何设置电阻、电容等参数随时间变化。但在实际模拟中&#xff0c;总会遇到需要模拟这些量的变化。故撰写此文&#xff0c;供大家参考。 除了模拟随时间变化外&#xff0c;同样的思路也可以模拟随其他变量变化 效果展示 设置电…

32【Aseprite 作图】石头——拆解

1 石头先画轮廓&#xff0c;还是2 4 1 1 2 2 2&#xff0c;这样画一个圆的轮廓 或者2 1 1 3 5 1 1 1 1 2 4 &#xff0c; 2 最暗一层的黑色&#xff0c;做阴影部分&#xff0c;就是7 4 3 2 做最深的部分 各个地方画一些浅色的&#xff0c;做高光部分&#xff0c;上面的高光偏圆…

015、列表_应用场景

1.消息队列 如图所示,Redis的lpush+brpop命令组合即可实现阻塞队列,生产者客户端使用lrpush从列表左侧插入元素,多个消费者客户端使用brpop命令阻塞式的“抢”列表尾部的元素,多个客户端保证了消费的负载均衡和高可用性。 2.文章列表 每个用户有属于自己的文章列表,现…

收银系统源码-千呼新零售2.0【智慧供应链】

千呼新零售2.0系统是零售行业连锁店一体化收银系统&#xff0c;包括线下收银线上商城连锁店管理ERP管理商品管理供应商管理会员营销等功能为一体&#xff0c;线上线下数据全部打通。 适用于商超、便利店、水果、生鲜、母婴、服装、零食、百货等连锁店使用。 详细介绍请查看下…