Pytorch创建张量

news/2024/7/21 7:30:25/文章来源:https://blog.csdn.net/qq_44815135/article/details/139243436

文章目录

    • 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.luyixian.cn/news_show_1053021.aspx

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

相关文章

概率分布函数与误差函数的关系

正态函数&#xff08;高斯分布&#xff09; 对其求[b,x]区间的积分 标准误差函数 以下两个方程相等&#xff08;a,b取值任意&#xff09; 两个函数重合 可知正态函数 f(t) 在[b,x]的区间上积分等于 引用desmos计算器&#xff1a;Desmos | Lets learn together.

9.4 Go语言入门(运算符)

Go语言入门&#xff08;运算符&#xff09; 目录三、运算符1. 算术运算符2. 关系运算符3. 逻辑运算符4. 位运算符5. 赋值运算符6. 其他运算符7. 运算符优先级 目录 Go 语言&#xff08;Golang&#xff09;是一种静态类型、编译型语言&#xff0c;由 Google 开发&#xff0c;专注…

他用AI,抄袭了我的AI作品

《大话西游》里面有一句经典台词&#xff1a;每个人都有一个妈&#xff0c;但是“你妈就一定是你妈吗&#xff1f;” 用AI创作的艺术作品&#xff0c;也走进类似的困境&#xff1a;如何证明你用AI生成的作品&#xff0c;就是你的作品&#xff1f; 近日&#xff0c;腾讯科技独…

编程-辅助工具-Git下载

文章目录 1、前言2、Git官网地址3、迅雷下载 1、前言 采用Git能下载github上的代码&#xff0c;其下载是采用官网下载的&#xff0c;但是下载速度比较慢&#xff0c;网上也推荐了镜像的方式&#xff0c;但是有些链接失效了&#xff0c;突然有一天想起用迅雷是不是合适&#xf…

【Sql Server】随机查询一条表记录,并重重温回顾下存储过程的封装和使用

大家好&#xff0c;我是全栈小5&#xff0c;欢迎来到《小5讲堂》。 这是《Sql Server》系列文章&#xff0c;每篇文章将以博主理解的角度展开讲解。 温馨提示&#xff1a;博主能力有限&#xff0c;理解水平有限&#xff0c;若有不对之处望指正&#xff01; 目录 前言随机查询语…

AI办公自动化:用kimi批量将word文档部分文件名保存到Excel中

文件夹中有很多个word文档&#xff0c;现在只要英文部分的文件名&#xff0c;保存到一个Excel文件中。 可以在kimi中输入提示词&#xff1a; 你是一个Python编程专家&#xff0c;要完成一个编写Python脚本的任务&#xff0c;具体步骤如下&#xff1a; 打开文件夹&#xff1a;…

Linux IO模型深度解析与实战应用

linux的5种IO模型 一、这里IO是什么 操作系统设有用户态与内核态,确保系统安全。应用程序默认在用户态运行,而执行如IO操作等底层任务时,需切换至内核态以高效执行。 服务器从网络接收的大致流程如下: 1、数据通过计算机网络来到了网卡 2、把网卡的数据读取到 socket 缓…

将 KNX 接入 Home Assistant 之一 准备硬件

不久前有人小伙伴买了usb转knx ,详情请看 一个 usb 转 knx 的模块 然后想通过这个设备接入 Home Assistant。 后来了解了一下 Home Assistant 并不直接支持 usb转KNX的接入&#xff0c;需要通过KNXD插件转接才行。 然而尝试了很多次叶没有成功&#xff0c;使用西门子的usb接口以…

Android面试题之Kotlin常见集合操作技巧

本文首发于公众号“AntDream”&#xff0c;欢迎微信搜索“AntDream”或扫描文章底部二维码关注&#xff0c;和我一起每天进步一点点 list 创建和修改 不可变list,listOf var list listOf("a","d","f") println(list.getOrElse(3){"Unkn…

关于高性能滤波器和普通型滤波器的区别说明

高性能滤波器和普通型滤波器在性能和滤波效果上存在显著差异。以三安培为代表分析高性能滤波器和普通型滤波器的区别&#xff1a; 从上图曲线可看出&#xff1a; 1.高性能滤波器和普通型滤波器的滤波范围不同。普通型滤波器有效滤波范围为 150KHz~30MHz&#xff0c;而高性能滤…

蓝牙Mesh模块多跳大数据量高带宽传输数据方法

随着物联网技术的飞速发展&#xff0c;越来越多的设备需要实现互联互通。蓝牙Mesh网络作为一种低功耗、高覆盖、易于部署的无线通信技术&#xff0c;已经成为物联网领域中的关键技术之一。在蓝牙Mesh网络中&#xff0c;节点之间可以通过多个跳数进行通信&#xff0c;从而实现大…

剪画小程序:”霸屏各大平台“的黏土滤镜是怎么制作的呢?

最近&#xff0c;网上出现大量“黏土”风格的人物照片。尤其是在社交平台&#xff0c;这类型的分享数量急剧上升。 这是马斯克开车的样子 还有这张是周杰伦七里香的专辑图片 一张照片&#xff0c;十几秒钟&#xff0c;就能还原出你在黏土世界的样子。 以上这些照片是用-【剪画…

解决SpringBoot中插入汉字变成?(一秒解决)

在这里url后面加一行配置即可&useUnicodetrue&characterEncodingUTF-8即可 解释 spring.datasource.url: 这里包含了数据库的URL&#xff0c;以及额外的参数如useUnicodetrue用于启用Unicode字符集支持&#xff0c;characterEncodingUTF-8用于指定字符编码为UTF-8&…

idea2024 nacos中文报错

idea2024 nacos中文报错 报错提示为&#xff1a;Input length 1 报错原因&#xff1a;项目启动编码与nacos编码不一致。 处理方式 添加启动参数utf8修改项目编码格式为utf8 修改idea.vmoptions Help -> Edit Custom 添加一行&#xff1a;-Dfile.encodingUTF-8

Django与微服务架构:构建可扩展的Web应用

title: Django与微服务架构&#xff1a;构建可扩展的Web应用 date: 2024/5/21 20:15:19 updated: 2024/5/21 20:15:19 categories: 后端开发 tags: 微服务Django负载均衡RESTfulAPI网关容器化监控安全 前言 在当今快速发展的软件开发领域&#xff0c;微服务架构已经成为构建…

情感分析及数据集代码解析

15.1. 情感分析及数据集 — 动手学深度学习 2.0.0 documentation (d2l.ai) 代码 import os import torch from torch import nn from d2l import torch as d2l#save d2l.DATA_HUB[aclImdb] (http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz,01ada507287d828…

音视频学习规划

文章目录 概述闲聊点 小结 概述 最近在学习音视频&#xff0c;觉得还是要先写个提纲&#xff0c;给自己制定下学习路线及目标。先写下我的个人流程及思路。 ffmpeg的命令ffmpeg api播放器流媒体RTMP&#xff0c;HLS 闲聊点 先说下学习命令行吧&#xff0c;学习命令行是为了…

【Spring Cloud】API网关

目录 什么是API网关为什么需要API网关前言问题列表 API网关解决了什么问题常见的网关解决方案NginxLuaSpring Cloud Netflix ZuulSpringCloud Zuul的IO模型弊端 Spring Cloud Gateway 第二代网关——GatewayGateway的特征Spring Cloud Gateway的处理流程Spring Cloud Gateway的…

基于trunk、yew构建web开发脚手架

trunk 构建、打包 rust wasm 程序&#xff1b;yewweb 前端开发库&#xff1b; 项目仓库yew-web trunk 之前已经简单介绍了trunk,全局安装&#xff1a; $> cargo install --locked trunk常用命令&#xff1a; trunk build 基于wasm-bindgen构建 wasm 程序。trunk watch …

企企通入选第一新声《2024年中国CIO数字化产品选型白皮书》供应链数字产品可信名录

近日&#xff0c;第一新声研究院根据多年产业数字化研究&#xff0c;历经近半年时间&#xff0c;并综合近200位CIO调研与推荐意见&#xff0c;发布《2024年中国CIO数字化产品选型白皮书》&#xff0c;并推出企业CIO选型指南及可信产品名录。企企通凭借其优秀的采购数字化与供应…