Tensor的概念
Tensor（张量）是一个多维数组，它是标量、向量、矩阵的高维拓展。
标量是一个零维张量，是没有方向的，是一个数。一维张量只有一个维度，是一行或者一列。二维张量是一个矩阵，有两个维度，灰度图片就是一个二维张量。当图像是彩色图像（RGB）的时候，就得使用三维张量了。
Tensor与Variable
张量在数学中是多维数组，在pytorch中，张量不仅仅表示多维数组，张量还是pytorch中自动求导的关键。说到张量与自动求导，就得提到variable这一数据类型。
variable是pytorch 0.4.0以前的版本中一个重要的数据类型。但是从pytorch0.4.0开始，variable并入到tensor 中。
理解variable对理解张量tensor是有帮助的。variable是torch.autograd中的数据类型，主要用于封装tensor，进行自动求导。variable主要由以下几个部分组成：
data:被包装的tensor；
grad:data的梯度；
grad_fn:创建tensor的function，是自动求导的关键；
requires_grad:指示是否需要梯度；
is_leaf:指示是否是叶子结点（张量）；
Tensor
pytorch自0.4.0版本后将variable并入tensor中；
在tensor中有8个部分，其中有5个部分在前面的variable中已经介绍了。剩余的3个部分分别为dtype，shape，device。
dtype:张量的数据类型，如torch.FloatTensor, torch.cuda.FloatTensor;
两个数据类型之间不同之处在于后者多了一个cuda，cuda表示数据是放到GPU上的。
shape:张量的形状，如（64，3，224，224）；
device:张量所在设备，GPU/CPU，是加速的关键；
pytorch提供了九种数据类型，主要分为三大类；
第一类是float浮点数，有16位(16-bit floating point)、32位(32-bit floating point)、64位(64-bit floating point);
第二类是整型，有8位（8-int integer(unsigned),8-int integer(signed)）,32位(32-bit integer(signed))，64-bit integer(signed);
第三类是布尔型数据(Boolean)。
用得最多的是32-bit floating point（卷积神经网络或者图片处理使用到）和64-bit integer(signed)（图像的标签通常用长整型进行表示）
tensor有八个属性，其中四个属性与数据相关，4个属性与梯度求导相关。
张量的创建
张量的创建有三大方法，第一类是直接创建，第二类是依据数值创建，第三类是依据概率创建。
一、直接创建
1.1 torch.tensor()
功能：从data创建tensor
- data:数据，可以是list, numpy；
- dtype:数据类型，默认与data的一致；
- device:所在设备，cuda/cpu；
- requires_grad:是否需要梯度；
- pin_memory:是否存于锁业内存；
torch.tensor(
data,
dtype=None,
device=None,
requires_grad=False,
pin_memory=False)
python实例：
import torch
import numpy as np
flag = True
if flag:
arr = np.ones((3,3))
print("ndarray的数据类型：", arr.dtype)
t = torch.tensor(arr)
t = torch.tensor(arr,device='cuda') //将数据放到GPU上
print(t)
1.2 torch.from_numpy(ndarray)
功能：从numpy创建tensor
注意事项：从torch.from_numpy创建的tensor与原ndarray共享内存，当修改其中一个的数据，另外一个也将会被改动。
从图中可以理解，tensor.data和ndarray共享内存，即通过ndarray修改数据，对应的tensor.data中对应的数值也会改变。
import torch
import numpy as np
flag = True
if flag:
arr = np.array([[1, 2, 3], [4, 5, 6]]) //创建一个array数组
t = torch.from_numpy(arr) //创建对应的tensor张量
print("numpy array: ", arr) //直接输出
print("tensor : ", t)
print("\n修改arr") //修改arr的值，看是否对张量t的值有影响
arr[0, 0] = 0
print("numpy array: ", arr)
print("tensor : ", t)
print("\n修改tensor") //修改张量t的值，看是否对数组arr的值有影响
t[0, 0] = -1
print("numpy array: ", arr)
print("tensor : ", t)
二、依据数值创建
2.1 torch.zeros()
功能：依size创建全0张量
- size:张量的形状，如（3，3）、（3，224，224）
- out:输出的张量
- layout:内存中布局形式，有strided，sparse_coo等
- device:所在设备，gpu/cpu
- requires_grad:是否需要梯度
torch.zeros(*size,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
import torch
import numpy as np
flag = True
if flag:
out_t = torch.tensor([1])
t = torch.zeros((3,3), out=out_t)
print(t, '\n', out_t)
print(id(t), id(out_t), id(t) == id(out_t))
2.2 torch.zeros_like()
功能：依input形状创建全0张量
- intput：创建与input同形状的全0张量
- dtype：数据类型
- layout：内存中布局形式
torch.zeros_like(input,
dtype=None,
layout=None,
device=None,
requires_grad=False)
除了全零矩阵，还可以使用全一矩阵
2.3 torch.ones()
2.4 torch.ones_like()
功能：依input形状创建全1张量
- size：张量的形状，如（3，3）、（3，224，224）
- dtype：数据类型
- layout：内存中布局形式
- device：所在设备，gpu/cpu
- requires_grad：是否需要梯度
torch.ones(*size,
out=None,
dtype=None,
layout=torch.stridedm
device=None,
requires_grad=False)
torch.ones_like(input,
dtype=None,
layout=None,
device=None,
requires_grad=False)
除了全零全一矩阵，还有自定义矩阵
2.5 torch.full()
2.6 torch.full_like()
功能：依input形状创建全0张量
- size：张量的形状，如（3，3）
- fill_value：张量的值
torch.full(size,
fill_value,
out=None,
dtype=None,
layout=torch.strided
device=None,
requires_grad=False)
import torch
import numpy as np
flag = True
if flag:
t = torch.full((3, 3), 10) //设定矩阵的形状为（3，3）,矩阵中每个值都为10
print(t)
2.7 torch.arange()
功能：创建等差的1维张量
注意事项：数值区间为[start,end)，end的值是取不到的。
- start：数列起始值
- end：数列“结束值”
- step：数列公差，默认为1
import torch
import numpy as np
flag = True
if flag:
t = torch.arange(2,10,2)
print(t)
2.8 torch.linspace()
功能：创建均为的1维张量
注意事项：数值区间为[start,end]
- start：数列起始值
- end：数列结束值
- steps：数列长度，即张量里面数字的个数
torch.linsoace(start,
end,
steps=100,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
import torch
import numpy as np
flag = True
if flag:
t = torch.linspace(2, 10, 5)
print(t) //输出为tensor([ 2., 4., 6., 8., 10.])
t = torch.linspace(2, 10, 6)
print(t) //输出为tensor([ 2.0000, 3.6000, 5.2000, 6.8000, 8.4000, 10.0000])
2.9 torch.logspace()
功能：创建对数均分的1维张量
注意事项：长度为steps，底为base
- start：数列起始值
- end：数列结束值
- steps：数列长度
- base：对数函数的底，默认为10
torch.logspace(start,
end,
steps=100,
base=10.0
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
2.10 torch.eye()
功能：创建单位对角矩阵（2维张量）
注意事项：默认为方阵
- n：矩阵行数
- m：矩阵列数
torch.eye(n,
m=None,
out=None,
dtype=None,
layout=torch.strided,
device=None,
require_grad=False)
三、依概率分布创建张量
3.1 torch.normal()
功能：生成正态分布（高斯分布）
- mean：均值
- std：标准差
注意mean和std分别有两种模式，分别为标量和张量。
torch.normal()分别有四种模式：
mean为标量，std为标量；
mean为标量，std为张量；
mean为张量，std为标量；
mean为张量，std为张量；
torch.normal(mean,
std,
out=None)
torch.normal(mean,
std,
size, //标量中要增加一个size用于确定张量的大小
out=None)
import torch
import numpy as np
flag = True
if flag:
# mean:张量 std:张量
mean = torch.arange(1, 5, dtype=torch.float)
std = torch.arange(1, 5, dtype=torch.float)
t_normal = torch.normal(mean, std)
print("mean:{}\nstd:{}".format(mean, std))
print(t_normal)
# mean:标量 std:标量
t_normal = torch.normal(0, 1, size=(4,)) #size用于决定张量的大小
print(t_normal)
# mean:张量 std:标量
mean = torch.arange(1, 5, dtype=torch.float)
std = 1
t_normal = torch.normal(mean, std)
print("mean:{}\nstd:{}".format(mean, std))
print(t_normal)
3.2 torch.randn()
3.3 torch.randn_like()
功能：生成标准正态分布
- size:张量的形状
torch.randn(*size,
out=None,
dtype=None,
layout=torch.strided
device=None,
requires_grad=False)
3.4 torch.rand()
3.5 torch.rand_like()
功能：在区间[0,1)上，生成均匀分布
3.6 torch.randint()
3.7 torch.randint_like()
功能：区间[low,high)生成整数均匀分布
- size:张量的形状
torch.rand(*size,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
torch.randint(low=0,
high,
size,
out=None,
dtype=None,
layout=torch.strided,
device=None,
requires_grad=False)
3.8 torch.randperm()
功能：生成从0到n-1的随机排列
- n:张量的长度
3.9 torch.bernoulli()
功能：以input为概率，生成伯努利分布（0-1分布，两点分布）
- input：概率值
torch.randperm(n,
out=None,
dtype=torch.int64,
layout=torch.strided,
device=None,
requires_grad=False)
torch.bernoulli(input,
*,
generator=None,
out=None)
628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
