Tensor（张量）
pyotch的核心的数据结构：torch.Tensor(python class, in  torch.Tensor).
torch.Tensor 是一个包含单一数据类型的多维矩阵。torch定义了9种数据类型可以在cpu和GPU上运算。（16，32，64位浮点型 ，8位 无符号整数型, 8,16, 32,64位 有符号整数型。布尔型）
该类的类属性和类方法见torch.Tensor
张量的创建
1、直接从数据构造tensor
x = torch.tensor([5.5, 3])
print(x)

输出：
tensor([5.5000, 3.0000])

2、创建特定的tensor
创建一个未初始化矩阵：
x = torch.empty(5, 3)
print(x)

输出：
tensor([[2.2391e-19, 4.5869e-41, 1.4191e-17],
        [4.5869e-41, 0.0000e+00, 0.0000e+00],
        [0.0000e+00, 0.0000e+00, 0.0000e+00],
        [0.0000e+00, 0.0000e+00, 0.0000e+00],
        [0.0000e+00, 0.0000e+00, 0.0000e+00]])

创建一个随机矩阵：
x = torch.rand(5, 3)
print(x)

输出：
tensor([[0.5307, 0.9752, 0.5376],
        [0.2789, 0.7219, 0.1254],
        [0.6700, 0.6100, 0.3484],
        [0.0922, 0.0779, 0.2446],
        [0.2967, 0.9481, 0.1311]])

创建一个全0矩阵：
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]])

其他类似命令参考creation-ops
3、从现有的tensor建立新的tensor
根据已有的tensor建立新的tensor。除非用户提供新的值，否则这些方法将重用输入张量的属性，例如dtype等：
x = x.new_ones(5, 3, dtype=torch.double)      # new_* methods take in sizes
print(x)

x = torch.randn_like(x, dtype=torch.float)    # 重载 dtype!
print(x)                                      # 结果size一致

输出：
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
tensor([[ 1.6040, -0.6769,  0.0555],
        [ 0.6273,  0.7683, -0.2838],
        [-0.7159, -0.5566, -0.2020],
        [ 0.6266,  0.3566,  1.4497],
        [-0.8092, -0.6741,  0.0406]])

4、桥接numpy
Tensor和numpy可以相互转换。
Torch Tensor与NumPy数组共享底层内存地址，修改一个会导致另一个的变化。
Tensor转化为numpy：
输入：
a = torch.ones(5)
print(a)

输出：
tensor([1., 1., 1., 1., 1.])

输入：
b = a.numpy()
print(b)

输出：
[1. 1. 1. 1. 1.]

当tensor  a改变时：
a.add_(1)  #做加法
print(a)
print(b)

输出：
tensor([2., 2., 2., 2., 2.])
[2. 2. 2. 2. 2.]

numpy数组相应改变
T
numpy转化为Tensor
同样的，numpy数组也会改变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)

Tensor在CPU和GPU的转换
一般情况下可以使用.cuda方法将tensor移动到gpu，这步操作需要cuda设备支持
输入：
cpu_a=torch.rand(4, 3)
cpu_a.type()

输出：
'torch.FloatTensor'

输入：
gpu_a=cpu_a.cuda()
gpu_a.type()

输出：
'torch.cuda.FloatTensor'

使用.cpu方法将tensor移动到cpu
cpu_b=gpu_a.cpu()
cpu_b.type()

输出：
'torch.FloatTensor'

如果我们有多GPU的情况，可以使用to方法来确定使用那个设备
#使用torch.cuda.is_available()来确定是否有cuda设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
#将tensor传送到设备
gpu_b=cpu_b.to(device)
gpu_b.type()

输出：
cuda
'torch.cuda.FloatTensor'

import torch
import numpy as np
 
print(torch.tensor([1,2,3]))
print(torch.tensor(np.arange(15).reshape(3,5)))
print(torch.empty([3,4]))
print(torch.ones([3,4]))
print(torch.zeros([3,4]))
#0-1之间的随机数
print(torch.rand([2,3]))
#3-10之间的随机整数
print(torch.randint(3,10,(2,2)))
#正态分布，均值为0，方差为1
print(torch.randn([3,4]))

转自：https://www.cnblogs.com/LiuXinyu12378/p/12292972.html

tensor - 张量

概述：
代码里面可以看成一个多维数组。
数学上一个叫多维矩阵，注意不是一个多维向量，自己开始竟然这都搞错了。

向量定义是具有大小和方向的量，也相当于高维空间中的一个点，代码上就相当于一个一维数组。

张量也可以看成高维空间的一个点，不过它形式上是多维矩阵（多维数组）的形式，而不是一维的形式，名字里面的‘’张‘’就是来源于一维边多维，张开了这个原因吧。
n维多维矩阵就是size[0] * size[1] * ... *size[n]个数有序排列组成的集合。第0维度的元素就是n-1维的多维数组或者多维矩阵.第n-1维对应一个0维的元素，第n-1维对于一个1维的数组。
形象化的想象可以是仓库里面的堆货，一个获取代表一个数，先横着放一排，一维，再一排一排的堆上多排，组成了一个个面，二维矩阵数组，然后再把这一个面网上堆，堆成了一个小堆，再一堆一堆的堆满一排的堆，就变成一个4维的数组了，然后在一排一排堆出一个面，仓库的一层，然后堆第二层，以此类推。

构造的时候是低维张量已经逐渐变成的高维的元素。所以index元素的时候要反过去想，

比如现在一个4维的张量x，x第0维度就是一堆货，一个3维张量，x的第4-1=3维度对应就是一货物。
注意张量里面的每个元素的类型是一样的。
pytorch定义了多种不同精度的浮点、复数、整数张量，比如torch.float32 注意在torch包下面。
还有稀疏张量，目前pytorch提供实验版的支持。

创建

tensor的创建方式：

1、要使用现有数据创建张量，请使用torch.tensor()。

直接使用python的多维数组或者numpy的多维数组

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

tensor([[ 1.0000, -1.0000],

[ 1.0000, -1.0000]])

torch.tensor(np.array([[1, 2, 3], [4, 5, 6]]))

tensor([[ 1,  2,  3],

[ 4,  5,  6]])

当然也可以使用tensor自身

2、要创建具有特定大小的张量，请使用torch.*张量创建操作（请参阅创建操作）。

创建张量：

2.1 直接传入数据创建

torch.tensor(list)

.tensor(ndarry)
2.2 设置各种属性进行创建

empty(size)

zeros(size)

new_ones(size)

rand(size) 用0-1之间的均匀分布填充的大小为size的tensor

randn(size) 用标准正态分布填充的大小为size的tensor, 注意这里的n是normal的意思，不是n个的意思

加上_lick , 根据现有的张量创建张量。 这些方法将重用输入张量的属性，例如， dtype，除非设置新的值进行覆盖

如 randn_like(a, )

传入的参数一般有size，dtype=torch.float 等
3、更多

要创建与另一张量具有相似类型但大小不同的张量，请使用Tensor.new_*creation ops。

如Tensor.new_full()使用某个值填充 Tensor.new_zero() Tensor.new_one() Tensor.new_empty()
4、和numpy相互转换

torch.tensor(a) 直接做参数传入

x = torch.from_numpy(a)

x.numpy()  # 没有to, 应该和转入时的from对应更好的
需要注意的是使用上面这样直接创建的方式，tensor会直接复制数据，如果不想复制，要采用其它方法，

If you have a Tensor data and just want to change its requires_grad flag, use requires_grad_() or detach() to avoid a copy. If you have a numpy array and want to avoid a copy, use torch.as_tensor().

如果对tensor需要改变requires_grad 标志，直接调用对应方法即可，

对于numpy数组防止拷贝，调用as_tensor方法。
可以通过构造器或者tensor的创建操作的地方指定tensor的数据类型，还可以指定使用gup。

torch.ones([2, 4], dtype=torch.float64, device=cuda0)
pytorch的tensor内部还有为自动微分提供支持的地方，传入requires_grad=true，表示记录发生在操作tensor上的操作，然后用来支持自动微分。
访问：

张量的内容可以像python的list一样用索引和切片符号来访问和修改。

可用torch.Tensor.item()从张量中获取包含单个值的Python数字。

每个张量都有一个关联的torch.Storage，用于保存其数据。
运算

张量的运算通过可以张量对象直接调用，也可以通过torch.xxx()调用

pytorch提供了很多张量之间的运算，如

加减

张量的三角函数值（应该是每个维度下面的三角函数合起来）

最接近的更大的整数张量

变到a-b以内，a-b数不变，两端以外的变成a或b

最大元素，最小元素

所有元素求和之后的对数

等等等等

提供了估计有上百个，也就是说常见的张量的操作这里面都提供了，一般都不用自己造轮子写的。

具体的待以后学习
我们对张量进行一些计算操作时，由于张量内存占用是比较大的，有时候需要返回新的张量，有时候直接在原张量上修改，所以pytorch设置了改变原张量值的计算方式和返回新值的计算方法，改变张量的方法用下划线后缀标记。例如，torch.FloatTensor.abs_()就地计算绝对值并返回修改后的张量，而torch.FloatTensor.abs() 在新张量中计算结果。
张量视图：

张量类提供多维数据的截面视图，形式上可以理解为类似于python的切片。

pytorch的张量视图和原来的张量是共享内存的，避免过多内存拷贝。

由上，张量视图可能改变元素之间的连续性，这时候需要注意性能上的一些影响。

张量内部有一个storage属性，存储了基础数据，应该可理解为保存元素的数组，然后有一个stride属性，表示在各个维度上遍历需要跨过的内存长度，比如345的三维数组，stride就是（20,5,1）
常见的涉及张量视图的操作如下：

Basic slicing and indexing op, e.g. tensor[0, 2:, 1:7:2] returns a view of base tensor, see note below.

as_strided()

detach()

diagonal()

expand()

expand_as()

narrow()

permute()

select()

squeeze()

transpose()

t()

T

real

imag

view_as_real()

view_as_imag()

unfold()

unsqueeze()

view()

view_as()

unbind()

split()

chunk()

indices() (sparse tensor only)

values() (sparse tensor only)
张量的转置，也就是高维空间，多维数组的转置，详见：

https://www.standbyside.com/2019/09/10/understanding-of-transpose-in-numpy/

矩阵转置是高维空间转置的二维情形，x，y交换，对应到多维情形就复杂一些了在二维坐标系下就是x，y交换

numpy数据的transpose(xxx， (2, 0, 1))，也就是现在的第0维度是原来的第二维，第一维是原来的第0维度，。

在3维坐标系下看z变成x，x变成y，y变成了z，更高维的不好想了，按照转化规则在代数上变化。

1. tf.split

该函数主要用于对tensor进行分割，一般在设置多GPU并行计算时经常会被用到，主要是将一个batch数据集进行平分，分配给各个GPU，最后再汇总各个GPU得到的损失，从而加快模型的训练速度，其主要参数的定义如下：

value：待分割的 `Tensor` .
	
num_or_size_splits： 可以是一个整数，表示分割的后的数量，也可以是一个整数列表，表示分割后每一份的size
	
axis：分割的维度，默认的第一维 
import tensorflow as tf

tf.split(
    value, 
    num_or_size_splits, 
    axis=0, 
    num=None, 
    name="split"
)

2. tf.add_n

该函数主要是对输入的tensor列表中每一个tensor进行加总，要求每个tensor的维度必须相同，当开启并行计算时，该函数也经常被用来计算各个GPU得到的损失，其主要参数定义如下：

inputs：一个tensor列表
import tensorflow as tf

tf.add_n(inputs, name=None)