[人工智能]PyTorch随笔-5

一、
1.PyTorch简介
PyTorch是一个优化的张量库，2017年1月，由Facebook人工智能研究院（FAIR）基于Torch推出，它是一个基于Python的可续计算包，可使用gpu和cpu进行深度学习,此外还支持动态神经网络。
PyTorch具有以下优点：
（1）PyTorch是相当简洁且高效快速的框架。
（2）设计追求最少的封装。
（3）设计符合人类思维，它让用户尽可能地专注于实现自己的想法。
（4）与google的Tensorflow类似，FAIR的支持足以确保PyTorch获得持续的开发更新。
（5）PyTorch由作者亲自维护其论坛，以供用户交流和求教问题。
（6）入门简单。
1.Torch
包 torch 包含了多维张量的数据结构以及基于其上的多种数学操作。另外，它也提供了多种工具，其中一些可以更有效地对张量和任意类型进行序列化。

它有CUDA 的对应实现，可以在NVIDIA GPU上进行张量运算(计算能力>=2.0)。
1.1 张量 Tensors
1.torch.is_tensor(obj)
如果obj 是一个pytorch张量，则返回True

参数： obj (Object) – 判断对象

/usr/bin/env python3

-- coding: utf-8 --

import torch

shape=(3,2,)
x_data = torch.zeros(shape)
print(f"Tensor: \n {x_data} \n")
print(f"IsTensor: \n {torch.is_tensor(x_data)} \n")

Tensor:
tensor([[0., 0.],
[0., 0.],
[0., 0.]])

IsTensor:
True

2.torch.is_storage [source]

torch.is_storage(obj)
如何obj 是一个pytorch storage对象，则返回True

/usr/bin/env python3

-- coding: utf-8 --

import torch

shape=(3,2,)
x_data = torch.ones(shape)
print(f"Tensor: \n {x_data} \n")
print(f"is_storage: \n {torch.is_storage(x_data)} \n")

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

is_storage:
False
3.
2.Tensor
2.1 概述
Tensor中文称为张量，张量（tensor）理论是数学的一个分支学科，张量在数学上定义为：它是矢量概念的推广，向量（指具有大小和方向的量）是一阶张量，是张量的特例，张量可表示的内容比向量更丰富，它可用来表示向量、标量（标量只有大小，没有方向）和其他张量之间的线性关系的多线性函数。
在PyTorch中，Tensor是一种特殊的数据结构，非常类似于数组和矩阵，它被用来编码模型的输入和输出，以及模型的参数。Tensor类似于NumPy的ndarray，但比NumPy更强大，Tensor还可以在gpu或其他硬件加速器上运行。事实上，Tensor和NumPy数组通常可以共享相同的底层内存，从而消除了复制数据的需要。张量也被优化为自动微分。

2.2 张量定义
一、创建张量
在Pytorch中创建张量的方法取决于实际应用场景，主要有以下几种方法：
1、torch.tensor函数
用预先存在的数据创建张量，可使用torch.tensor函数。函数格式如下：
torch.tensor(data, , dtype=None, device=None, requires_grad=False, pin_memory=False) → Tensor
该函数有以下几个参数。
（1）Data：表示要构造张量的数据，可以是list、tuple、NumPy ndarray、scalar和其他类型。
（2）dtype (torch.dtype,可选参数) ：期望返回张量的数据类型。默认参数值为None，即：从数据推断数据类型。
（3）device (torch.device,可选参数)：用于CPU的CPU张量类型或用于CUDA的CUDA张量类型，参数值由设备类型（‘cpu’或’cuda’）和可选的设备的序号组成（如果设备序号不存在，该对象将始终代表设备类型的当前设备），比如：
torch.device(‘cuda:0’)或torch.device(‘cuda’, 0)表示0号cuda设备。
torch.device(‘cpu:0’)或torch.device(‘cpu’, 0)表示0号cpu设备。
默认参数值为None，即：使用当前设备作为默认张量类型(参见torch.set_default_tensor_type())。
（4）requires_grad (bool,可选参数)：autograd是否记录返回张量的操作。默认值:False。
（5）pin_memory (bool,可选参数) ：返回的张量是否被分配到固定的内存中。只适用于CPU张量。默认值:False。
2、torch. tensor 函数创建具有特定大小的张量。
3、torch.like函数创建一个与另一个张量具有相同大小（和类似类型）的张量。
4、tensor.new 函数创建与另一个张量类型相似但大小不同的张量。
5、torch.Tensor类
这不是一个函数，而是包含单一数据类型元素的多维矩阵类，是默认的tensor类(torch.FloatTensor) 的简称。前述1-4方法调用成功后返回结果都是Tensor类对象。
二、张量基本操作
下面以几个例子具体讲解张量的基本操作。
1、程序1-2-2-1.py创建了一个空tensor，为2*5的矩阵(空矩阵的元素值为未初始化状态，可理解为随机值)。
#!/usr/bin/env python3

-- coding: utf-8 --

#1-2-2-1.py
import torch
x=torch.Tensor(2,5)
print(x)
程序输出结果如下：
tensor([[3.8335e-40, 3.8338e-40, 9.1835e-41, 1.0691e+24, 4.1588e+21],
[1.8128e+34, 2.1565e+29, 8.6163e+09, 1.8004e+25, 1.8032e+22]])
2、程序1-2-2-2.py创建一个空tensor，为3*5的矩阵，并返回tensor矩阵元素数据类型为torch.float32和矩阵的类型torch.FloatTensor。
#!/usr/bin/env python3

-- coding: utf-8 --

#1-2-2-2.py
import torch
x=torch.Tensor(3,5)
print(x.dtype)
print(x.type())
程序执行结果如下：
torch.float32
torch.FloatTensor
3、程序1-2-2-3.py创建了几个空tensor，都为3*5的矩阵，然后依次输出它们元素数据类型和矩阵数据类型。
#!/usr/bin/env python3

-- coding: utf-8 --

#1-2-2-3.py
import torch
x=torch.DoubleTensor(3,5)
print(x.dtype)
print(x.type())
y=torch.BoolTensor(3,5)
print(y.dtype)
print(y.type())
程序执行结果如下：
torch.float64
torch.DoubleTensor
torch.bool
torch.BoolTensor
观察程序1-2-2-3.py及上述执行结果，不难看出：x是双精度浮点数（float64）类矩阵DoubleTensor，而是y布尔（逻辑）类矩阵BoolTensor。
4、程序1-2-2-4.py依次使用Python的列表和元组构造Tensor。
#!/usr/bin/env python3

-- coding: utf-8 --

#1-2-2-4.py
import torch
x1=torch.tensor([[10,20],[2,4]])
print(x1)
print(x1.size())
y=((11,21),(11,66))
x2=torch.tensor(y)
print(x2)
执行结果如下：
tensor([[10, 20],
[ 2, 4]])
torch.Size([2, 2])
tensor([[11, 21],
[11, 66]])
程序1-2-2-4.py首先传入列表为参数，调用torch.tensor函数定义FloatTensor类矩阵x1，并输出矩阵元素及其大小（2*2）；然后传入元组y作为参数，调用torch.tensor函数定义FloatTensor类矩阵x2，并输出矩阵元素。
5、程序1-2-2-5.py依次定义双精度矩阵和整数型矩阵。
#!/usr/bin/env python3

-- coding: utf-8 --

#1-2-2-5.py
import torch
a=[[10.2,20.6],[2,4]]
x=torch.DoubleTensor(a)
print(x)
y=torch.IntTensor(a)
print(y)
b=[[1,2],[3,4]]
z=torch.IntTensor(b)
print(z)
程序运行结果如下：
tensor([[10.2000, 20.6000],
[ 2.0000, 4.0000]], dtype=torch.float64)
D:\pro\learnAIpy\src\1-2-2-5.py:8: DeprecationWarning: an integer is required (got type float). Implicit conversion to integers using int is deprecated, and may be removed in a future version of Python.
y=torch.IntTensor(a)
tensor([[10, 20],
[ 2, 4]], dtype=torch.int32)
tensor([[1, 2],
[3, 4]], dtype=torch.int32)

2.3 初始化张量
2.3.1 从数据中创建
张量可以直接从数据中创建，自动判断数据类型。
import torch
data = [[11.0, 2],[3, 44.0]]
x_data = torch.tensor(data)
print(x_data)
data = [[11, 2],[3, 44]]
x_data = torch.tensor(data)
print(x_data)
运行结果：
tensor([[11., 2.],
[ 3., 44.]])
tensor([[11, 2],
[ 3, 44]])

使用 torch.Tensor.item() 从包含单个值的张量中获取Python数，请执行以下操作：

import torch
y=torch.tensor([[1,2],[3,4]])
print(y)

print(y[1,1].item())
tensor([[1, 2],
[3, 4]])

2.3.2 从NumPy 数组创建

import torch
import numpy as np
data = [[11.0, 2],[3, 44.0]]
np_array=np.array(data)
x_np = torch.from_numpy(np_array)
print(x_np)
运行结果：
tensor([[11., 2.],
[ 3., 44.]], dtype=torch.float64)

如果有一个numpy数组并希望避免复制 ，可使用torch.as_tensor()。

import torch
import numpy as np
a = np.arange(8)
b = a.reshape(4,2)
print (b)
y=torch.torch.as_tensor(b)
print(y)
y[1][1]=55
print(y)
print(b)

[[0 1]
[2 3]
[4 5]
[6 7]]
tensor([[0, 1],
[2, 3],
[4, 5],
[6, 7]])
tensor([[ 0, 1],
[ 2, 55],
[ 4, 5],
[ 6, 7]])
[[ 0 1]
[ 2 55]
[ 4 5]
[ 6 7]]

2.3.3 从其它tensor创建

import torch
import numpy as np
data = [[11.0, 2],[3, 44.0]]
x_data = torch.tensor(data)
print(f”Tensor: \n {x_data} \n")
运行结果：

Tensor:
tensor([[11., 2.],
[ 3., 44.]])

2.3.4 随机值创建tensor
import torch
import numpy as np
shape=(3,4,)
x_data = torch.rand(shape)
print(f"Tensor: \n {x_data} \n")
运行结果：

Tensor:
tensor([[0.5137, 0.2523, 0.4290, 0.8971],
[0.6080, 0.6341, 0.3161, 0.1189],
[0.5905, 0.0437, 0.0408, 0.5235]])

2.3.5 零矩阵、单位矩阵等

import torch
import numpy as np
shape=(3,4,)
x_data = torch.zeros(shape)
print(f"Tensor: \n {x_data} \n")
x_data = torch.ones(shape)
print(f"Tensor: \n {x_data} \n")
运行结果：
Tensor:
tensor([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])

Tensor:
tensor([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
单位矩阵
在线性代数中，n阶单位矩阵，是一个n × n 的方形矩阵，其主对角线元素为1，其余元素为0。在矩阵的乘法中，起着特殊的作用，如同数的乘法中的1，根据单位矩阵的特点，任何矩阵与单位矩阵相乘都等于本身。
print(torch.eye(5))#对象线为1，其余为0，单位矩阵
tensor([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
import torch
print(torch.zeros(2,3,2))
print(torch.ones(2,4))
print(torch.rand(2,3))#[0,1]随机数
print(torch.arange(2,8))#序列
print(torch.arange(2,10,3))

tensor([[[0., 0.],
[0., 0.],
[0., 0.]],

    [[0., 0.],
     [0., 0.],
     [0., 0.]]])

tensor([[1., 1., 1., 1.],
[1., 1., 1., 1.]])
tensor([[0.2293, 0.5129, 0.2397],
[0.3889, 0.5081, 0.4054]])
tensor([2, 3, 4, 5, 6, 7])
tensor([2, 5, 8])

2.3.6 torch数据类型

Pytorch的张量的数据类型以数值类型为主，定义了以下几种CPU张量和对应的GPU张量类型，如下表所示。
数据类型 dtype CPU张量 GPU张量
32-bit floating point torch.float32?or?torch.float torch.FloatTensor torch.cuda.FloatTensor
64-bit floating point torch.float64?or?torch.double torch.DoubleTensor torch.cuda.DoubleTensor
16-bit floating point?1 torch.float16?or?torch.half torch.HalfTensor torch.cuda.HalfTensor
16-bit floating point?2 torch.bfloat16 torch.BFloat16Tensor torch.cuda.BFloat16Tensor
32-bit complex torch.complex32
64-bit complex torch.complex64
128-bit complex torch.complex128?or?torch.cdouble
8-bit integer (unsigned) torch.uint8 torch.ByteTensor torch.cuda.ByteTensor
8-bit integer (signed) torch.int8 torch.CharTensor torch.cuda.CharTensor
16-bit integer (signed) torch.int16?or?torch.short torch.ShortTensor torch.cuda.ShortTensor
32-bit integer (signed) torch.int32?or?torch.int torch.IntTensor torch.cuda.IntTensor
64-bit integer (signed) torch.int64?or?torch.long torch.LongTensor torch.cuda.LongTensor
Boolean torch.bool torch.BoolTensor torch.cuda.BoolTensor

2.3.7 torch所在设备
torch.device是一个对象，它代表一个torch所在的设备，张量被分配在该设备里。device包含一个设备类型(‘cpu’或’cuda’)和设备类型的可选设备序号。 如果设备序号不存在，这个对象将始终代表设备类型的当前设备。

特定数据类型的tensor可以被构造，通过 torch.dtype和/或torch.device，对于构造函数或张量创建操作。

cuda0 = torch.device(‘cuda:0’)
torch.ones([2, 4], dtype=torch.float64, device=cuda0)
tensor([[ 1.0000, 1.0000, 1.0000, 1.0000],
[ 1.0000, 1.0000, 1.0000, 1.0000]], dtype=torch.float64, device=‘cuda:0’)

2.4 tensor访问与操作
2.4.1 索引和切片表示法
可以使用Python的索引和切片表示法访问和修改tensor的内容：

import torch
y=torch.tensor([[1,2],[3,4]])
print(y)
print(y[1,:])
print(y[:,0])
print(y[:,1])

tensor([[1, 2],
[3, 4]])
tensor([3, 4])
tensor([1, 3])
tensor([2, 4])

2.4.2 记录操作
可使用requires_grad=True创建张量，以便torch.autograd记录对它们的操作以进行自动区分。
import torch
x = torch.tensor([[1., 2.], [3., 4.]], requires_grad=True)
out = x.pow(2).sum()
out.backward()
print(x.grad)

tensor([[2., 4.],
[6., 8.]])
2.4.3 tensor 数据保存
每个 tensor 都有一个相关的 torch.Storage,，它保存数据。tensor类还提供了存储的多维、跨视图，并定义了对存储的数字操作。
改变tensor的方法用下划线后缀标记。例如，torch.FloatTensor.abs_()就地计算绝对值并返回修改后的张量，而torch.FloatTensor.abs_()以新的tensor张量计算结果。
改变现有的张量 torch.device 和/或torch.dtype，考虑对张量使用to（）方法。
当前执行的 torch.Tensor 引入内存开销，因此在具有许多小张量tensor的应用程序中可能会导致意外的高内存使用率
二、