深度学习Pytorch-张量

千白莫

 关注

阅读 122

2022-03-24

深度学习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=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的数列的随机排列

相关推荐

学习pytorch-张量数据类型

蓝莲听雨 51 0 0

【动手学深度学习】pytorch-参数管理

young_d807 77 0 0

深度学习（3）---PyTorch中的张量

高子歌 47 0 0

深度学习 pytorch的使用（张量2）

心存浪漫 16 0 0

[三十]深度学习Pytorch-图像目标检测Faster RCNN

舟海君 189 0 0

[三十一]深度学习Pytorch-生成对抗网络GAN

大南瓜鸭 106 0 0

[二十八]深度学习Pytorch-图像分类Resnet18

月孛星君 139 0 0

深度学习02-pytorch-07-张量的拼接操作

青青子衿谈育儿 51 0 0

深度学习：张量 介绍

ixiaoyang8 19 0 0

pytorch-模型保存

四月Ren间 63 0 0

精彩评论（0）

0 0 举报