当前位置:   article > 正文

Pytorch基本操作_x = y.to(device)

x = y.to(device)

基本元素操作

·Tensors张量:张量的概念类似于Numpy中的ndarray数据机构,最大的区别在于Tensor可以利用GPU的加速功能。

·我们使用Pytorch的时候,常规步骤是先将torch引用进来,如下所示:

  1. from __future__ import print_function
  2. import torch

·创建矩阵的操作

·创建一个没有初始化的矩阵

  1. x = torch.empty(5, 3)
  2. print(x)

·输出结果

  1. tensor([[8.9082e-39, 6.9796e-39, 9.0919e-39],
  2.         [9.9184e-39, 7.3470e-39, 1.0194e-38],
  3.         [1.0469e-38, 1.0010e-38, 8.4490e-39],
  4.         [1.1112e-38, 9.5511e-39, 1.0102e-38],
  5.         [7.3470e-39, 1.0653e-38, 1.0194e-38]])

·创建一个有初始化的矩阵

  1. x = torch.rand(5, 3)
  2. print(x)

·输出结果

  1. tensor([[0.4131, 0.9503, 0.6787],
  2.         [0.4152, 0.3765, 0.7076],
  3.         [0.7593, 0.4818, 0.6114],
  4.         [0.9367, 0.9751, 0.4312],
  5.         [0.1160, 0.9584, 0.9142]])

·对比有无初始化的矩阵;当声明一个未初始化的矩阵时,它本身不包含任何确切的值,当创建一个未初始化的矩阵时,分配给矩阵的内存中有什么数值就赋值给了这个矩阵,本质上是毫无意义的数据

·创建一个全零矩阵并可指定数据元素的类型为long

  1. x = torch.zeros(5, 3, dtype=torch.long)
  2. print(x)

·输出结果

  1. tensor([[0, 0, 0],
  2.         [0, 0, 0],
  3.         [0, 0, 0],
  4.         [0, 0, 0],
  5.         [0, 0, 0]])

·直接通过数据创建张量

  1. x = torch.tensor([2.5, 3.5])
  2. print(x)

·输出结果

tensor([2.5000, 3.5000])

·通过已有的一个张量创建相同尺寸的新张量

#引用news_methods方法得到一个张量

  1. x = x.new_ones(5, 3, dtype=torch.double)
  2. print(x)
  3. #利用randn_like方法得到相同张量尺寸的一个新张量,并且采用随机初始化来对其赋值。
  4. y = torch.randn_like(x, dtype=torch.float)
  5. print(y)

·输出结果

  1. tensor([[1., 1., 1.],
  2.         [1., 1., 1.],
  3.         [1., 1., 1.],
  4.         [1., 1., 1.],
  5.         [1., 1., 1.]], dtype=torch.float64)
  6. tensor([[-0.5876,  1.3036, -0.3869],
  7.         [ 1.7733,  0.1932,  0.2446],
  8.         [ 0.5916,  1.2084, -0.1035],
  9.         [ 1.3692,  1.1909, -2.2429],
  10.         [-0.3186, -1.4448,  1.0075]])   #采用标准正态分布进行初始化

·得到张量的尺寸

print(x.size)

·输出结果

torch.Size([5, 3])

·注意

·torch.Size函数本质上返回的是一个tuple(元组),因此他支持一切元组的操作

加法操作

  1. y = torch.rand(5, 3)
  2. print(x + y)

·输出结果

  1. tensor([[1.5351, 1.6842, 1.3666],
  2.         [1.3795, 1.8638, 1.3811],
  3.         [1.0541, 1.7301, 1.0899],
  4.         [1.8753, 1.7973, 1.4234],
  5.         [1.5610, 1.8953, 1.6338]], dtype=torch.float64)

·第二种加法方式

print(torch.add(x, y))

·输出结果

  1. tensor([[1.7277, 1.9559, 1.1531],
  2.         [1.6201, 1.5433, 1.9186],
  3.         [1.7482, 1.1966, 1.7893],
  4.         [1.2140, 1.6189, 1.1661],
  5.         [1.0954, 1.3963, 1.9146]], dtype=torch.float64)

·第三种加法方式

  1. #提前设定一个空的张量
  2. result = torch.empty(5, 3)
  3. #将空的张量作为加法的结果储存张量
  4. torch.add(x, y, out=result)
  5. print(result)

·输出结果

  1. tensor([[1.6799, 1.9276, 1.9753],
  2.         [1.7507, 1.1125, 1.5353],
  3.         [1.1135, 1.2286, 1.8567],
  4.         [1.0847, 1.5680, 1.7244],
  5.         [1.7176, 1.8635, 1.4754]])

·第四种加法方式:in-place(原地置换)

  1. y.add_(x)
  2. print(y)

·输出结果

  1. tensor([[1.3709, 1.1069, 1.7186],
  2.         [1.6112, 1.8828, 1.3935],
  3.         [1.2912, 1.3112, 1.0213],
  4.         [1.5485, 1.0155, 1.8169],
  5.         [1.3625, 1.5086, 1.0970]])

·注意

     ·所有in-place的操作函数都有一个下划线的后缀

      ·比如x.copy_(y), x.add_(y)都会直接改变x的值

·用类似于Numpy的方式对张量进行操作:

print(x[:, 1])

·输出结果

tensor([1., 1., 1., 1., 1.], dtype=torch.float64)

·改变张量的形状:torch.view()

  1. x = torch.randn(4, 4)
  2. # tensor.view()操作需要保证数据元素的总数量不变
  3. z = x.view(-1, 8)
  4. print(x.size(), y.size(), z.size())

·输出结果

torch.Size([4, 4]) torch.Size([5, 3]) torch.Size([2, 8])
  1. x = torch.randn(4, 4)
  2. # tensor.view()操作需要保证数据元素的总数量不变
  3. z = x.view(-1, 8)
  4. y = x.view(16)
  5. print(x.size(), y.size(), z.size())

·输出结果

torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])

        ··注意!!元素的个数一定不能改变

·如果张量中只有一个元素,可以用.item()将值取出,作为一个python umber

item.randn(1)表示将第一个值取出,作为一个python number

  1. x = torch.randn(1)
  2. print(x)
  3. print(x.item())

·输出结果

  1. tensor([-1.2572])
  2. -1.257204294204712

·注意!!.item只能提取单一的一个值

·关于Torch Tensor和Numpy array之间的相互转换

·Torch Tensor和Numpy array共享底层的内存空间,因此改变其中一个的值,另一个也会随之被改变。

  1. a = torch.ones(5)
  2. print(a)

·输出结果

tensor([1., 1., 1., 1., 1.])

·将Torch Tensor转换为Numpy array

  1. b = a.numpy()
  2. print(b)

·输出结果

[1. 1. 1. 1. 1.]

·对其中一个进行加法操作,另一个也随之被改变

  1. a.add_(1)
  2. print(a)
  3. print(b)

·输出结果

  1. tensor([2., 2., 2., 2., 2.])
  2. [2. 2. 2. 2. 2.]

·将Numpy array转换为Torch Tensor

  1. import numpy as np
  2. a = np.ones(5)
  3. b = torch.from_numpy(a)
  4. np.add(a, 1, out=a)
  5. print(a)
  6. print(b)

输出结果

  1. [2. 2. 2. 2. 2.]
  2. tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

··注意!!

       ··在所有CPU上的Tensors,除了CharTensor,都可以转换为Numpy array并可以反向转换。

·关于Cuda Tensor,Tensor可以用.to()的方法来将其移动到任意设备上。

  1. # 如果服务器上已安装了GPU和CUDA
  2. if torch.cuda.is_available():
  3. #定义一个设备对象,这里指定成CUDA,即使用GPU
  4. device = torch.device("cuda")
  5. #直接在GPU上创建一个Tensor
  6. y = torch.ones_like(x, device=device)
  7. #将在CPU上面的x张量移动到GPU上面
  8. x = x.to(device)
  9. #x和y都在GPU上面,才能支持加法运算
  10. z = x + y
  11. #此处的张量z在GPU上面
  12. print(z)
  13. #也可以将z转移到CPU上面,并同时指定张量元素的数据类型
  14. print(z.to("cpu", torch.double))

·输出结果

  1. tensor([0.6469], device='cuda:0')
  2. tensor([0.6469], dtype=torch.float64)

总结

·什么是Pytorch

        ·Pytorch是一个基于Numpy的科学计算包,作为Numpy的代替者,向用户提供使用GPU强大功能的能力。

        ·作为一款深度学习的平台,向用户提供最大的灵活性和速度。

·Pytorch的基本元素操作

        ·矩阵的初始化:

                ·torch.empty()

                ·torch.randn(n, m)

                ·torch.zeros(n, m, dtype=torch.double)

        ·其他若干操作:

                ·x.new_ones(n, m, dtype=torch.double)

                ·torch.randn_like(x, dtype=torch.float)

                ·x.size

        ·Pytorch的基本运算操作。

                ·加法操作:

                        ·x +y

                        ·torch.add(x, y)

                        ·torch.add(x, y, out=result)

                        ·y.add_(x)

                ·其他若干操作

                        ·x.view()

                        ·x.item()

·Torch Tensor和Numpy array之间的相互转换。

        ·将Torch Tensor转换为Numpy array:

                ·b = a.numpy()

        ·将Numpy array转换为Torch Tensor:

                ·b = torch.from_numpy(a)

        ·注意:所有在CPU上的Tensor,除了CharTensor,都可以转换为Numpy array并可以反向转换。

·任意的Tensors可以用.to()的方法来将其移动到任意设备上。

        ·x = x.to(device)

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/716017
推荐阅读
相关标签
  

闽ICP备14008679号