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

基本元素操作

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

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

from __future__ import print_function
import torch

·创建矩阵的操作

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

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

·输出结果

tensor([[8.9082e-39, 6.9796e-39, 9.0919e-39],
 
        [9.9184e-39, 7.3470e-39, 1.0194e-38],
 
        [1.0469e-38, 1.0010e-38, 8.4490e-39],
 
        [1.1112e-38, 9.5511e-39, 1.0102e-38],
 
        [7.3470e-39, 1.0653e-38, 1.0194e-38]])

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

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

·输出结果

tensor([[0.4131, 0.9503, 0.6787],
 
        [0.4152, 0.3765, 0.7076],
 
        [0.7593, 0.4818, 0.6114],
 
        [0.9367, 0.9751, 0.4312],
 
        [0.1160, 0.9584, 0.9142]])

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

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

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

·输出结果

tensor([[0, 0, 0],
 
        [0, 0, 0],
 
        [0, 0, 0],
 
        [0, 0, 0],
 
        [0, 0, 0]])

·直接通过数据创建张量

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

·输出结果

tensor([2.5000, 3.5000])

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

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

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

·输出结果

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

·得到张量的尺寸

print(x.size)

·输出结果

torch.Size([5, 3])

·注意

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

加法操作

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

·输出结果

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

·第二种加法方式

print(torch.add(x, y))

·输出结果

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

·第三种加法方式

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

·输出结果

tensor([[1.6799, 1.9276, 1.9753],
 
        [1.7507, 1.1125, 1.5353],
 
        [1.1135, 1.2286, 1.8567],
 
        [1.0847, 1.5680, 1.7244],
 
        [1.7176, 1.8635, 1.4754]])

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

y.add_(x)
print(y)

·输出结果

tensor([[1.3709, 1.1069, 1.7186],
 
        [1.6112, 1.8828, 1.3935],
 
        [1.2912, 1.3112, 1.0213],
 
        [1.5485, 1.0155, 1.8169],
 
        [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()

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

·输出结果

torch.Size([4, 4]) torch.Size([5, 3]) torch.Size([2, 8])

x = torch.randn(4, 4)
# tensor.view()操作需要保证数据元素的总数量不变
z = x.view(-1, 8)
y = x.view(16)
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

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

·输出结果

tensor([-1.2572])
-1.257204294204712

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

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

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

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

·输出结果

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

·将Torch Tensor转换为Numpy array

b = a.numpy()
print(b)

·输出结果

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

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

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

·输出结果

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

·将Numpy array转换为Torch Tensor

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

输出结果

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

··注意！！

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

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

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

·输出结果

tensor([0.6469], device='cuda:0')
 
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)