PyTorch深度学习基础

最新推荐文章于 2023-06-09 17:30:50 发布
最新推荐文章于 2023-06-09 17:30:50 发布
阅读量431 收藏 3
点赞数 1
分类专栏： pytorch实战 文章标签： pytorch python 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41287133/article/details/120378924
版权

PyTorch深度学习基础

一、Tensor对象及其运算

1、torch.tensor()创建Tensor对象

使用tensor数据类型时，可以通过dtype属性指定它的数据类型

print('torch.Tensor 默认为：{}'.format(torch.Tensor(1).dtype))
print('torch.tensor 默认为：{}'.format(torch.tensor(1).dtype))
'''
torch.Tensor 默认为：torch.float32
torch.tensor 默认为：torch.int64
'''

# 用list构建tensor
a = torch.tensor([[1, 2], [3, 4]], dtype=torch.float64)
print(a)
'''
tensor([[1., 2.],
        [3., 4.]], dtype=torch.float64)
'''

# 用np.array构建tensor
b = torch.tensor(np.array([[1, 2], [3, 4]]), dtype=torch.uint8)
print(b)
'''
tensor([[1, 2],
        [3, 4]], dtype=torch.uint8)
'''
'''
2、torch.device()指定设备
# 通过device指定设备
cuda0 = torch.device('cuda:0')
c = torch.ones((2, 2), device=cuda0)
# print(c)
'''
tensor([[1., 1.],
        [1., 1.]], device='cuda:0')
'''
3、torch.mm执行矩阵乘法
a = torch.tensor([[1, 2], [3, 4]])
b = torch.tensor([[1, 2], [3, 4]])

# 逐元素相乘
c = a * b
print("逐元素相乘:", c)
'''
逐元素相乘: tensor([[ 1,  4],
                  [ 9, 16]])
'''
# 矩阵相乘
c = torch.mm(a, b)
print("矩阵相乘", c)
'''
矩阵相乘: tensor([[ 7, 10],
                [15, 22]])
'''
4、torch.clamp分段函数

常用于过滤矩阵中过小或过大的元素

a = torch.tensor([[1, 2], [3, 4]])
print(torch.clamp(a, min=2, max=3))
'''tensor([[2, 2],
           [3, 3]])'''
5、torch.round将小数化整
a = torch.tensor([-1.501, -1.5, -1.499, 0.499, 0.5, 0.501])
print(torch.round(a))
'''
tensor([-2., -2., -1.,  0.,  0.,  1.])
大于0.5则为1， 小于等于0.5则为0
'''
6、torch.tanh计算双曲正切函数
a = torch.Tensor([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5])
print(torch.tanh(a))
'''
tensor([-0.9999, -0.9993, -0.9951, -0.9640, -0.7616,  0.0000,  0.7616,  0.9640,
         0.9951,  0.9993,  0.9999])
'''
7、torch.arange
  1. torch.arange和python中的range函数用法相同
  2. 接收参数为起始值、结束值、步长（默认为1）
for i in range(1, 6):
    print(i)
'''
1
2
3
4
5
'''

a = torch.range(1, 5, 2)
print("torch.range(1, 5, 2): ", a)
print("torch.range(1, 5, 2).type: ", a.dtype)
b = torch.arange(1, 5, 2)
print("torch.arange(1, 5, 2): ", b)
print("torch.arange(1, 5, 2).type: ", b.dtype)
'''
torch.range(1, 5, 2):  tensor([1., 3., 5.])
torch.range(1, 5, 2).type:  torch.float32
torch.arange(1, 5, 2):  tensor([1, 3])
torch.arange(1, 5, 2).type:  torch.int64
'''

总结：

  1. torch.range是包含头尾的，而torch.arange是不包含尾的（和python的range函数一样）
  2. torch.range创建的tensor类型是torch.float32，而torch.arange创建的tensor类型是torch.int64
8、torch.linspace在指定范围内生成指定个数元素的

torch.linspace生成含指定头尾的n个参数的一维tensor

print(torch.linspace(1, 10, 5))
'''
tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])
'''
9、torch.ones返回全1矩阵
print(torch.ones((3, 3)))
'''
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])
'''
10、torch.zeros返回全零矩阵
print(torch.zeros((3, 3)))
'''
tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
'''
11、torch.rand返回[0，1]均匀分布采样元素组成的矩阵
print(torch.rand(3, 3))
'''
tensor([[0.4122, 0.6305, 0.1612],
        [0.4039, 0.0532, 0.3719],
        [0.4255, 0.2876, 0.3646]])
'''
12、torch.randn返回正态分布采样元素组成的矩阵
print(torch.randn(3, 3))
'''
tensor([[ 0.4774,  0.4414,  1.5994],
        [-0.0403,  0.5516,  1.1847],
        [ 1.0757,  0.0362,  0.9328]])
'''
13、torch.randint返回指定区间均匀分布采样的随机整数组成的矩阵
print(torch.randint(1, 5, (3, 3)))
'''
tensor([[3, 2, 2],
        [3, 1, 1],
        [4, 3, 4]])
'''

二、Tensor的索引和切片

1、基本索引
a = torch.arange(16).view(4, 4)
print(a)
'''
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15]])
'''
print(a[2, 3])
'''tensor(11)'''
2、切片
a = torch.rand(3, 3, 3, 3)
print(a)
'''
tensor([[[[0.7442, 0.6572, 0.8844],
          [0.2714, 0.9543, 0.7813],
          [0.2124, 0.6246, 0.2005]],

         [[0.5282, 0.0026, 0.3609],
          [0.6771, 0.5858, 0.9272],
          [0.1732, 0.5411, 0.8177]],

         [[0.4464, 0.2875, 0.5549],
          [0.2754, 0.7300, 0.8469],
          [0.6238, 0.5733, 0.5625]]],


        [[[0.5165, 0.3800, 0.0851],
          [0.0991, 0.7287, 0.9255],
          [0.9094, 0.1059, 0.2375]],

         [[0.8601, 0.7303, 0.3683],
          [0.3715, 0.1885, 0.6126],
          [0.5266, 0.4642, 0.8999]],

         [[0.4903, 0.1294, 0.0379],
          [0.5235, 0.2812, 0.2052],
          [0.3850, 0.2854, 0.8109]]],


        [[[0.4168, 0.4594, 0.1869],
          [0.2987, 0.7347, 0.3478],
          [0.1939, 0.3430, 0.8521]],

         [[0.7731, 0.8609, 0.3416],
          [0.9221, 0.2054, 0.4342],
          [0.6090, 0.6602, 0.1535]],

         [[0.4223, 0.2500, 0.3425],
          [0.7285, 0.1590, 0.2787],
          [0.8561, 0.1645, 0.3753]]]])
# '''

# 取第一个维度的前两个数据
print(a[:2])
'''
tensor([[[[0.7442, 0.6572, 0.8844],
          [0.2714, 0.9543, 0.7813],
          [0.2124, 0.6246, 0.2005]],

         [[0.5282, 0.0026, 0.3609],
          [0.6771, 0.5858, 0.9272],
          [0.1732, 0.5411, 0.8177]],

         [[0.4464, 0.2875, 0.5549],
          [0.2754, 0.7300, 0.8469],
          [0.6238, 0.5733, 0.5625]]],


        [[[0.5165, 0.3800, 0.0851],
          [0.0991, 0.7287, 0.9255],
          [0.9094, 0.1059, 0.2375]],

         [[0.8601, 0.7303, 0.3683],
          [0.3715, 0.1885, 0.6126],
          [0.5266, 0.4642, 0.8999]],

         [[0.4903, 0.1294, 0.0379],
          [0.5235, 0.2812, 0.2052],
          [0.3850, 0.2854, 0.8109]]]])
'''

# 取第一个维度的前两个数据，取第2个维度的前1个数据，后两个维度全都取到
print(a[:2, :1, :, :])
'''
tensor([[[[0.7442, 0.6572, 0.8844],
          [0.2714, 0.9543, 0.7813],
          [0.2124, 0.6246, 0.2005]]],


        [[[0.5165, 0.3800, 0.0851],
          [0.0991, 0.7287, 0.9255],
          [0.9094, 0.1059, 0.2375]]]])
'''

# 取第一个维度的前两个数据，取第2个维度的第1个索引到最后索引的数据(包含1)，后两个维度全都取到
print(a[:2, 1:, :, :])
'''
tensor([[[[0.5282, 0.0026, 0.3609],
          [0.6771, 0.5858, 0.9272],
          [0.1732, 0.5411, 0.8177]],

         [[0.4464, 0.2875, 0.5549],
          [0.2754, 0.7300, 0.8469],
          [0.6238, 0.5733, 0.5625]]],


        [[[0.8601, 0.7303, 0.3683],
          [0.3715, 0.1885, 0.6126],
          [0.5266, 0.4642, 0.8999]],

         [[0.4903, 0.1294, 0.0379],
          [0.5235, 0.2812, 0.2052],
          [0.3850, 0.2854, 0.8109]]]])
'''

# 负号表示第2个维度上从倒数第3个数据取到最后倒数第一个数据-1(包含-3)
print(a[:2, -3:])
'''
tensor([[[[0.7442, 0.6572, 0.8844],
          [0.2714, 0.9543, 0.7813],
          [0.2124, 0.6246, 0.2005]],

         [[0.5282, 0.0026, 0.3609],
          [0.6771, 0.5858, 0.9272],
          [0.1732, 0.5411, 0.8177]],

         [[0.4464, 0.2875, 0.5549],
          [0.2754, 0.7300, 0.8469],
          [0.6238, 0.5733, 0.5625]]],


        [[[0.5165, 0.3800, 0.0851],
          [0.0991, 0.7287, 0.9255],
          [0.9094, 0.1059, 0.2375]],

         [[0.8601, 0.7303, 0.3683],
          [0.3715, 0.1885, 0.6126],
          [0.5266, 0.4642, 0.8999]],

         [[0.4903, 0.1294, 0.0379],
          [0.5235, 0.2812, 0.2052],
          [0.3850, 0.2854, 0.8109]]]])
'''

# 两个冒号表示隔行取数据，一定的间隔
print(a[:, :, 0:3:2, 0:3:1])
'''
tensor([[[[0.7442, 0.6572, 0.8844],
          [0.2124, 0.6246, 0.2005]],

         [[0.5282, 0.0026, 0.3609],
          [0.1732, 0.5411, 0.8177]],

         [[0.4464, 0.2875, 0.5549],
          [0.6238, 0.5733, 0.5625]]],


        [[[0.5165, 0.3800, 0.0851],
          [0.9094, 0.1059, 0.2375]],

         [[0.8601, 0.7303, 0.3683],
          [0.5266, 0.4642, 0.8999]],

         [[0.4903, 0.1294, 0.0379],
          [0.3850, 0.2854, 0.8109]]],


        [[[0.4168, 0.4594, 0.1869],
          [0.1939, 0.3430, 0.8521]],

         [[0.7731, 0.8609, 0.3416],
          [0.6090, 0.6602, 0.1535]],

         [[0.4223, 0.2500, 0.3425],
          [0.8561, 0.1645, 0.3753]]]])
'''

# 两个冒号直接写表示从所有的数据中隔行取数据
print(a[:, :, ::1, ::1])
'''
tensor([[[[0.7442, 0.6572, 0.8844],
          [0.2714, 0.9543, 0.7813],
          [0.2124, 0.6246, 0.2005]],

         [[0.5282, 0.0026, 0.3609],
          [0.6771, 0.5858, 0.9272],
          [0.1732, 0.5411, 0.8177]],

         [[0.4464, 0.2875, 0.5549],
          [0.2754, 0.7300, 0.8469],
          [0.6238, 0.5733, 0.5625]]],


        [[[0.5165, 0.3800, 0.0851],
          [0.0991, 0.7287, 0.9255],
          [0.9094, 0.1059, 0.2375]],

         [[0.8601, 0.7303, 0.3683],
          [0.3715, 0.1885, 0.6126],
          [0.5266, 0.4642, 0.8999]],

         [[0.4903, 0.1294, 0.0379],
          [0.5235, 0.2812, 0.2052],
          [0.3850, 0.2854, 0.8109]]],


        [[[0.4168, 0.4594, 0.1869],
          [0.2987, 0.7347, 0.3478],
          [0.1939, 0.3430, 0.8521]],

         [[0.7731, 0.8609, 0.3416],
          [0.9221, 0.2054, 0.4342],
          [0.6090, 0.6602, 0.1535]],

         [[0.4223, 0.2500, 0.3425],
          [0.7285, 0.1590, 0.2787],
          [0.8561, 0.1645, 0.3753]]]])
'''
3、整数索引
a = torch.randn((3, 3))
print(a)
rows = [1, 2]
cols = [2]
print(a[rows, cols])
'''
第二、三行，第三列的元素
tensor([[-1.1423,  0.4933,  1.2880],
        [ 0.4578,  0.3748, -0.0443],
        [ 0.1310, -1.1097, -2.0845]])
tensor([-0.0443, -2.0845])
'''
4、布尔索引
a = torch.arange(9).view(3, 3)
index = a > 4
print(index)
print(a[index])
'''
tensor([[False, False, False],
        [False, False,  True],
        [ True,  True,  True]])
tensor([5, 6, 7, 8])
'''

index = torch.nonzero(a >= 8)
print(index)
'''
torch.nonzero用于返回非零值的索引矩阵
tensor([[2, 2]])
'''
5、torch.where(condition, x, y)

判断condition条件是否满足，当某个元素满足时，则返回对应矩阵x相同位置的元素，否则返回矩阵y的元素

x = torch.randn(3, 3)
y = torch.ones(3, 3)
print(x)
print(torch.where(x > 0, x, y))
'''
tensor([[-0.2932,  1.1689,  1.0301],
        [-0.0757, -0.1569,  1.3105],
        [ 1.6842,  0.8742,  1.7629]])
tensor([[1.0000, 1.1689, 1.0301],
        [1.0000, 1.0000, 1.3105],
        [1.6842, 0.8742, 1.7629]])
'''

三、Tensor的变换、拼接、拆分

1、Tensor.nelement和Tensor.ndimension查看Tensor信息
a = torch.rand(1, 2, 3, 4, 5)
print("元素个数: ", a.nelement())
print("轴的个数: ", a.ndimension())
print("矩阵维度： ", a.shape, a.shape[0], a.shape[1], a.shape[2])
'''
元素个数:  120
轴的个数:  5
矩阵维度：  torch.Size([1, 2, 3, 4, 5]) 1 2 3
'''
2、Tensor.view和Tensor.reshape更改Tensor维度
  1. Tensor.view要求Tensor的物理存储必须是连续的
  2. 输出的矩阵元素个数不能改变，在维度上输出-1，PyTorch会自动判断
a = torch.rand(1, 2, 3, 4)
b = a.view(6, 4)
print(b.shape)
c = a.reshape(-1)
print(c.shape)
d = a.reshape(6, -1)
print(d.shape)
'''
torch.Size([6, 4])
torch.Size([24])
torch.Size([6, 4])
'''
3、torch.squeeze和torch.unsqueeze
a = torch.rand(1, 2, 3, 4)
print(a.shape)
b = torch.squeeze(a)
print(b.shape)
c = torch.unsqueeze(b, 2)
print(c.shape)
'''
torch.Size([1, 2, 3, 4])
torch.Size([2, 3, 4])
torch.Size([2, 3, 1, 4])
'''
4、torch.transpose转置Tensor的两个维度
a = torch.rand(1, 2, 3, 4)
print(a.shape)
b = torch.transpose(a, 1, 3)
print(b.shape)
'''
torch.Size([1, 2, 3, 4])
torch.Size([1, 4, 3, 2])
'''
5、Tensor.permute任意变换Tensor维度
a = torch.rand(1, 2, 3, 4)
print(a.shape)
b = a.permute(2, 1, 3, 0)
print(b.shape)
'''
torch.Size([1, 2, 3, 4])
torch.Size([3, 2, 4, 1])
'''
6、torch.cat和torch.stack拼接矩阵
  1. torch.cat在已有的轴dim上拼接矩阵，给定轴的维度可以不同，其他轴的维度必须相同，dim默认为0
  2. torch.stack在新的轴上拼接，要求被拼接的矩阵所有维度都相同
a = torch.rand(2, 3)
b = torch.rand(3, 3)

c = torch.cat((a, b))
print(c.shape)

d = torch.stack((a, a))
print(d.shape)
'''
torch.Size([5, 3])
torch.Size([2, 2, 3])
'''

c = torch.stack((b, b), dim=0)
print(c.shape)
d = torch.stack((b, b), dim=1)
print(d.shape)
'''
torch.Size([2, 3, 3])
torch.Size([3, 2, 3])
'''
7、torch.split和torch.chunk拆分矩阵
  1. torch.split传入的是拆分后每个矩阵的大小，可以为整数，也可以为list集合
  2. torch.chunk传入的是拆分的矩阵个数
a = torch.randn(10, 2)
for x in torch.split(a, [1, 2, 3, 4], dim=0):
    print(x.shape)
'''
torch.Size([1, 2])
torch.Size([2, 2])
torch.Size([3, 2])
torch.Size([4, 2])
'''

for x in torch.split(a, 4, dim=0):
    print(x.shape)
'''
torch.Size([4, 2])
torch.Size([4, 2])
torch.Size([2, 2])
'''

for x in torch.chunk(a, 4, dim=0):
    print(x.shape)
'''
torch.Size([3, 2])
torch.Size([3, 2])
torch.Size([3, 2])
torch.Size([1, 2])
'''

四、PyTorch的Reduction操作

1、tensor.max找极大值
  1. 不指定维度的话返回全局最大值
  2. 指定维度的话，返回最大值及其索引
a = torch.Tensor([[1, 2], [3, 4]])
print(torch.max(a))
print(torch.max(a, dim=0))
'''
tensor(4.)
torch.return_types.max(
values=tensor([3., 4.]),
indices=tensor([1, 1]))
'''
2、tensor.cumsum进行累加
a = torch.Tensor([[1, 2], [3, 4]])
print(torch.cumsum(a, dim=1))
'''
tensor([[1., 3.],
        [3., 7.]])
'''
3、tensor.cumprod进行累乘
a = torch.Tensor([[1, 2], [3, 4]])
print(torch.cumprod(a, dim=1))
'''
tensor([[ 1.,  2.],
        [ 3., 12.]])
'''
4、tensor.mean、tensor.median、tensor.std计算矩阵的均值，中值，协方差
a = torch.Tensor([[1, 2], [3, 4]])
print(a.mean(), a.median(), a.std())
'''
tensor(2.5000) tensor(2.) tensor(1.2910)
'''
5、tensor.unique找到矩阵出现了哪些元素
a = torch.randint(1, 5, (3, 4))
print(a)
print(torch.unique(a))
'''
tensor([[1, 2, 2, 2],
        [1, 1, 1, 4],
        [2, 3, 1, 3]])
tensor([1, 2, 3, 4])
'''

五、PyTorch的自动微分

将Tensor的requires_grad设置为True，pytorch的torch.autograd会自动地追踪他的计算轨迹，需要计算微分的时候，只需要对最终计算结果的Tensor调用backward方法，中间所有节点的微分就会保存在grad属性中

1、backward
x = torch.randn(3, 3, requires_grad=True)
print(x)
w = torch.ones(3, 3, requires_grad=True)
y = torch.sum(torch.mm(x, w))
print(y)
'''
tensor([[ 0.4195, -0.5490, -0.4192],
        [ 0.5463,  2.0776, -1.0063],
        [-0.0103,  1.2296,  0.1743]], requires_grad=True)
tensor(7.3874, grad_fn=<SumBackward0>)
'''
y.backward()
print(y.grad)
print(w.grad)
print(x.grad)
'''
None
tensor([[ 0.9554,  0.9554,  0.9554],
        [ 2.7582,  2.7582,  2.7582],
        [-1.2512, -1.2512, -1.2512]])
tensor([[3., 3., 3.],
        [3., 3., 3.],
        [3., 3., 3.]])
'''
2、Tensor.detach将Tensor从计算图剥离出去，不再计算它的微分
x = torch.rand(3, 3, requires_grad=True)
w = torch.ones(3, 3, requires_grad=True)
print(x)
print(w)
'''
tensor([[0.9318, 0.3074, 0.0789],
        [0.3595, 0.9793, 0.2073],
        [0.8808, 0.7111, 0.6849]], requires_grad=True)
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], requires_grad=True)
'''
yy = torch.mm(x, w)

detached_yy = yy.detach()
print(detached_yy)
'''
tensor([[1.3181, 1.3181, 1.3181],
        [1.5461, 1.5461, 1.5461],
        [2.2768, 2.2768, 2.2768]])
'''
y = torch.mean(yy)
y.backward()

print(x.grad)
print(w.grad)
print(yy.grad)
'''
tensor([[0.3333, 0.3333, 0.3333],
        [0.3333, 0.3333, 0.3333],
        [0.3333, 0.3333, 0.3333]])
tensor([[0.2413, 0.2413, 0.2413],
        [0.2220, 0.2220, 0.2220],
        [0.1079, 0.1079, 0.1079]])
None
'''
3、with torch.no_grad()包含的代码段不会计算微分
x = torch.rand(3, 3, requires_grad=True)
w = torch.ones(3, 3, requires_grad=True)

y = torch.sum(torch.mm(x, w))
print(y.requires_grad)
'''True'''
with torch.no_grad():
    y = torch.sum(torch.mm(x, w))
    print(y.requires_grad)
    '''False'''
fair_wu
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
深度学习之Pytorch基础教程！
Datawhale
07-24 787
↑↑↑关注后"星标"Datawhale每日干货&每月组队学习，不错过Datawhale干货作者：李祖贤，Datawhale高校群成员，深圳大学随着深度学习...
Pytorch深度学习基础
03-12
Pytorch深度学习基础
深度学习之【pytorch入门】——Pytorch基础
weixin_45709330的博客
04-05 240
pytorch基础 pytorch中的Tensor 概念 Tensor是指张量，是pytorch中的数据类型。其中，一个点叫0阶张量，一维数据（向量）是一阶张量，二维数组（矩阵）是二阶张量，三维数组就叫三阶张量，张量是矢量概念的一种推广。 Tensor定义 注意：Python中[[1,2],[2,3]]，表示[1,2]、[2,3]表示行 torch.FloatTensor 这个可以生成一个浮点类...
《动手学深度学习》 第二天 （线性回归）
tsundere_x的博客
04-08 330
3.2 线性回归的从零开始实现 只利用NDArray和autograd来实现一个线性回归的训练。 首先，导入本节中实验所需的包或模块，其中的matplotlib包可用于作图，且设置成嵌入显示。 %matplotlib inline from IPython import display from matplotlib import pyplot as plt from mxnet import a...
深度学习-各种卷积的总结
记录学习的小白
06-09 1783
如果你听说过深度学习中不同种类的卷积（比如 2D / 3D / 1x1 /转置/扩张（Atrous）/空间可分/深度可分/平展/分组/混洗分组卷积），并且搞不清楚它们究竟是什么意思，那么这篇文章就是为你写的，能帮你理解它们实际的工作方式。在这篇文章中，我会归纳总结深度学习中常用的几种卷积，并会试图用一种每个人都能理解的方式解释它们。除了本文之外，还有一些关于这一主题的好文章，请参看原文。希望本文能帮助你构建起对卷积的直观认知，并成为你研究或学习的有用参考。
第4章 PyTorch深度学习基础
06-17
第4章 PyTorch深度学习基础
Pytorch深度学习基础 实战天气图片识别（基于ResNet50预训练模型，超详细）.zip
最新发布
05-08
Pytorch深度学习基础 实战天气图片识别（基于ResNet50预训练模型，超详细）.zip
pytorch深度学习入门与简明实战教程2022
10-05
2.深度学习基础与线性回归实例 3.pytorch张量 4.逻辑回归与多层感知机 5.多分类问题 6.手写数字全连接模型 7.基础部分总结 8.计算机视觉基础 9.预训练模型(迁移学习) 10.Dataset数据输入 11.现代网络架构 12.图像...
【torch小知识点02】torch.range()和torch.arange()的区别
羊老羊
01-23 1279
torch.arange() 和 torch.range()区别
pytorch每日一学20(torch.arange()、torch.range()、torch.linespace()、torch.logspace())根据步长创造一维tensor
Fluid_ray的博客
11-17 1万+
第20学 此次学习所有的根据步长创建一维tensor的几个方法，因为基本相似，所以把他们都放在一起，并进行比较。 torch.arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor torch.range(start=0, end, step=1, *, out=None, dtype=None, layout=torch
pyTorch中torch.range()和torch.arange()的区别
Bryce-HJ
07-14 2460
torch.range()和torch.arange()的区别 x = torch.range(-8, 8) y = torch.arange(-8, 8) print(x, x.dtype) print(y, y.dtype) output：    tensor([-8., -7., -6., -5., -4., -3., -2., -1., 0., 1., 2., 3., 4., 5.,6., 7., 8.]) torch.float32    tensor([-8, -7, -6,
pytorch.range() 和 pytorch.arange()
weixin_36670529的博客
05-12 520
>>> y=torch.range(1,6) >>> y tensor([1., 2., 3., 4., 5., 6.]) >>> y.dtype torch.float32 >>> z=torch.arange(1,6) >>> z tensor([1, 2, 3, 4, 5]) >>&gt...
torch.tensor和torch.Tensor
Andy1814的博客
08-10 546
在torch的tensor使用过程中，我们经常回看到torch.tensor()和类似于torch.Tensor()或者torch.FloatTesnor()、tensor.DoubleTensor()等等，究竟两种用法该怎么区分呢？ 首先，要说的是，上面列出的几种初始化方法，我们统一的归为两类：大写和小写 小写：torch.tensor() 大写：torch.Tensor()或者torch.FloatTesnor()、tensor.DoubleTensor()诸如此类用Tensor开头的 小写：一
PyTorch中Tensor的数据类型和运算
热门推荐
ch_musk的博客
06-28 2万+
在使用Tensor时，我们首先要掌握如何使用Tensor来定义不同数据类型的变量。Tensor时张量的英文，表示多维矩阵，和numpy对应，PyTorch中的Tensor可以和numpy的ndarray相互转换，唯一不同的是PyTorch可以在GPU上运行，而numpy的ndarray只能在cpu上运行。 常用的不同数据类型的Tensor，有32位的浮点型torch.F...
torch.range()和torch.arange()的区别
qq_39697468的博客
10-14 1777
1. torch.arange()方法可以通过输出一个值来进行创建随机数，而torch.range()不可以； 2. torch.arange()不包含end的值。
torch.arange （不是 torch.range，不要用torch.range）
OrdinaryMatthew的博客
11-20 1190
左闭右开区间。
torch.arrange和torch.range用法
weixin_47156261的博客
05-09 4645
torch.arrange:
日常笔记：Lua & Torch
Simon's Blog
07-14 1万+
Code Zoo，这个名字取自于深度学习框架 caffe 中著名的模型集合：Caffe Model Zoo。就是想把我平时用 Torch 时做深度学习时，写的 Lua 代码，如脚本工具、Lua 和 Torch 中的处理函数、使用过程中跳进去的坑…整理集中起来，供以后参考，也给需要的同学一点线索。
pytorch深度学习教程
08-17
对于PyTorch深度学习教程，CSDN上有很多优质的资源可以供您学习。您可以在CSDN中搜索相关的教程和文章，以下是一些经典的教程推荐： 1. PyTorch官方文档：PyTorch官方提供了详细的文档和教程，从基础到高级内容都有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值