0
点赞
收藏
分享

微信扫一扫

深度学习Pytorch-张量

深度学习Pytorch-张量定义与创建

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=11维张量;
(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)功能:创建basestart次方为起始值,baseend次方为终止值的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的数列的随机排列

举报

相关推荐

0 条评论