深度学习Pytorch-张量定义与创建
- 1. 张量定义
- 2. 张量的创建
- 2.1 直接创建
- 2.2 依据数值创建
- 2.2.1 tourch.zeros(*size)
- 2.2.2 torch.zeros_like(input)
- 2.2.3 torch.ones(*size)
- 2.2.4 torch.ones_like(input)
- 2.2.5 torch.full(size, fill_value)
- 2.2.6 torch.full_like((input, fill_value)
- 2.2.7 torch.arange(start=0, end, step=1)
- 2.2.8 torch.linspace(start, end, steps=100)
- 2.2.9 torch.logspace(start, end, steps=100, base=10.0)
1. 张量定义
1.1 张量是什么?
张量是一个多维数组,它是标量、向量、矩阵的高维拓展。
1.2 Tensor与Variable
1.3 Tensor
tourch.cuda.FloatTensor表示数据是放在GPU上
torch.tensor(arr, device=’cuda’)
2. 张量的创建
2.1 直接创建
2.1.1 torch.tensor(data)
torch.tensor(data, dtype=None, device=None, requires_grad=False, pin_memory=False)
(1)功能:从data
中创建tensor
(2)参数:
data:
数据,可以是list
, tuple
, numpy
, array
, scalar
或其他类型;
dtype:
创建tensor
的数据类型,默认与data
的数据类型一致;
device:
创建的tensor
所在的设备,cuda
or cpu
;
requires_grad:
是否需要梯度;
pin_memory:
是否存于锁页内存;
(3)代码示例
# =============================== exmaple 1 ===============================
# 通过torch.tensor创建张量
#
# flag = True
flag = False
if flag:
arr = np.ones((3, 3)) #[[1, 1, 1],[1, 1, 1],[1, 1, 1]]
print("ndarray的数据类型:", arr.dtype)
#cuda表示使用GPU,此时需要将tensor将CPU转换到GPU上
t = torch.tensor(arr, device='cuda')
# t = torch.tensor(arr)
print(t)
2.1.2 torch.from_numpy(ndarray)
(1)功能:从numpy
创建tensor
(2)特别注意:从torch.from_numpy
创建的tensor
和原来的ndarray
是共享内存
,当修改其中任何一个数据,另一个也会相应被修改。
(3)代码示例:
# =============================== exmaple 2 ===============================
# 通过torch.from_numpy创建张量
# flag = True
flag = False
if flag:
arr = np.array([[1, 2, 3], [4, 5, 6]])
t = torch.from_numpy(arr)
# print("numpy array: ", arr)
# print("tensor : ", t)
# print("\n修改arr")
# arr[0, 0] = 0 #表示将arr的第0行第0列元素置0,此时tensor的0行0列元素也等于0
# print("numpy array: ", arr)
# print("tensor : ", t)
print("\n修改tensor")
t[0, 0] = -1 #表示将tensor的第0行第0列元素置-1,此时arr的0行0列元素也等于-1
print("numpy array: ", arr)
print("tensor : ", t)
2.2 依据数值创建
2.2.1 tourch.zeros(*size)
torch.zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
(1)功能:根据size
来创建size
大小的全0
张量;
(2)参数:
size:
输出张量的形状。可以是可变数量的参数,也可以是列表或元组之类的集合。
out:
输出的张量。
dtype:
指定返回tensor
中数据的类型,如果为None
,使用默认值(一般为torch.float32
,可以使用 torch.set_default_tensor_type()
更改。)
layout:
内存中张量的布局形式,默认为strided
密集型张量,还有torch.sparse_coo
稀疏性张量(用于存储稀疏矩阵时使用的布局,可以提高读取效率)。
device:
返回tensor
所处的设备,可以是cpu
或者cuda
,默认为cpu
。
requires_grad:
返回的tensor
是否需要梯度,默认为False
。
(3)代码示例:
# =============================== exmaple 3 ===============================
# 通过torch.zeros创建张量
# flag = True
flag = False
if flag:
out_t = torch.tensor([1]) #随便创造一个张量
t = torch.zeros((3, 3), out=out_t) #创建一个3*3的全零张量并输出至out_t
print(t, '\n', out_t) #t与out_t都输出为3*3的全零张量
#id(t)是显示内存地址,id(t) == id(out_t)输出True,证明t与out_t的内存地址相同
print(id(t), id(out_t), id(t) == id(out_t))
2.2.2 torch.zeros_like(input)
torch.zeros_like(input, dtype=None, layout=None, device=None, requires_grad=False)
(1)功能:根据input
的形状来创建全0
的张量
(2)参数:
input:
与input
同形状的张量;
(3)代码示例:
input = torch.rand(3, 4)
print(input)
# tensor([[0.5840, 0.8260, 0.7539, 0.2138],
# [0.9743, 0.0964, 0.7610, 0.5746],
# [0.6247, 0.3334, 0.6949, 0.9065]])
#与input形状相同、元素全为0
b = torch.zeros_like(input)
print(b)
# tensor([[0., 0., 0., 0.],
# [0., 0., 0., 0.],
# [0., 0., 0., 0.]])
2.2.3 torch.ones(*size)
torch.ones(*sizes, out=None, dtype=None, layout=None, device=None, requires_grad=False)
(1)功能:创建一个大小为size
的全1
张量;
(2)参数:
size:
大小为size
的张量,如(3,3) (3,224,224)
;
(3)代码示例:
print(torch.ones(3,2))
# tensor([[1., 1.],
# [1., 1.],
# [1., 1.]])
2.2.4 torch.ones_like(input)
torch.ones_like(input, dtype=None, layout=None, device=None, requires_grad=False)
(1)功能:根据input的形状来创建全1的张量
(2)参数:
input:
input
形状大小;
(3)代码示例:
import torch
input = torch.rand(3, 4)
a = torch.ones_like(input)
print(a)
# tensor([[1., 1., 1., 1.],
# [1., 1., 1., 1.],
# [1., 1., 1., 1.]])
2.2.5 torch.full(size, fill_value)
torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
(1)功能:创建一个大小为size
,数值全为fill_value
的张量;
(2)参数:
size:
张量的形状大小,比如(3,3)
;
fill_value:
张量中所有的值;
(3)代码示例:
# =============================== exmaple 4 ===============================
# 通过torch.full创建全1张量
# flag = True
flag = False
if flag:
t = torch.full((3, 3), 1) #创造一个3*3的张量,数值全为1
print(t)
2.2.6 torch.full_like((input, fill_value)
torch.full_like((input, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
(1)功能:创建与input
相同size
,数值全为fill_value
的张量
(2)参数:
size:
张量大小为size
;
fill_value:
张量的值;
(3)代码示例:
import torch
input = torch.rand(3, 4)
print(input)
# tensor([[0.5840, 0.8260, 0.7539, 0.2138],
# [0.9743, 0.0964, 0.7610, 0.5746],
# [0.6247, 0.3334, 0.6949, 0.9065]])
#与input形状相同、元素全为3
c = torch.full_like(input,3)
print(c)
# tensor([[3., 3., 3., 3.],
# [3., 3., 3., 3.],
# [3., 3., 3., 3.]])
2.2.7 torch.arange(start=0, end, step=1)
torch.arange(start=0, end, step=1, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
(1)功能:创建数值区间为[start, end)
,步长为step=1
的1
维张量;
(2)参数:
start:
起始值;
end:
“结束值”,但是实际上是开区间
;
step:
步长,默认为1
;
(3)代码示例:
# =============================== exmaple 5 ===============================
# 通过torch.arange创建等差数列张量
# flag = True
flag = False
if flag:
t = torch.arange(2, 10, 2) #创建[2,4,6,8]张量,因为区间是[2,10)
print(t)
2.2.8 torch.linspace(start, end, steps=100)
torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
(1)功能:创建数值区间为[start, end)
,均分为100
份的1
维张量;
(2)参数:
steps:
张量的长度;
步长=(end-start)/(steps-1)
;
(3)代码示例:
# =============================== exmaple 6 ===============================
# 通过torch.linspace创建均分数列张量
# flag = True
flag = False
if flag:
# t = torch.linspace(2, 10, 5) #创建起始是2,结束是10,长度为5的张量,输出[2.,4.,6.,8.,10.]
#创建长度为6的张量,输出为[2.0000, 3.6000, 5.2000, 6.8000, 8.4000, 10.0000] 步长=(10-2)/(6-1)
t = torch.linspace(2, 10, 6)
print(t)
2.2.9 torch.logspace(start, end, steps=100, base=10.0)
torch.logspace(start, end, steps=100, base=10.0, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)
(1)功能:创建base
的start
次方为起始值,base
的end
次方为终止值的steps
个数构成的等比数列(1维张量
);
(2)参数:
base:
指数函数的底,默认是10
;
steps:
张量的长度;
(3)代码示例:
#创建10^0.1为起始值,10^1.0为终止值的等比数列,个数为5个。
torch.logspace(start=0.1, end=1.0, steps=5)
#tensor([ 1.2589, 2.1135, 3.5481, 5.9566, 10.0000])
10^0.1=1.2589
10^(0.1+(1-0.1)/4)=2.1135
10^(0.1+(1-0.1)/4*2)=3.5481
10^(0.1+(1-0.1)/4*3)=5.9566
10^(0.1+(1-0.1)/4*4)=10^1=10
根据矩阵要求:
torch.eye(n, m=None, out=None,…) #返回2-D 的单位对角矩阵
1
torch.empty(*sizes, out=None, …) #返回被未初始化的数值填充,大小为sizes的tensor
torch.empty_like(input, …) # 返回与input相同size,并被未初始化的数值填充的tensor
随机采用生成:
torch.normal(mean, std, out=None)
1
torch.rand(*size, out=None, dtype=None, …) #返回[0,1]之间均匀分布的随机数值
torch.rand_like(input, dtype=None, …) #返回与input相同size的tensor, 填充均匀分布的随机数值
torch.randint(low=0, high, size,…) #返回均匀分布的[low,high]之间的整数随机值
torch.randint_like(input, low=0, high, dtype=None, …) #
torch.randn(*sizes, out=None, …) #返回大小为size,由均值为0,方差为1的正态分布的随机数值
torch.randn_like(input, dtype=None, …)
torch.randperm(n, out=None, dtype=torch.int64) # 返回0到n-1的数列的随机排列