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

0. 往期内容

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

[二]深度学习Pytorch-张量的操作：拼接、切分、索引和变换

[三]深度学习Pytorch-张量数学运算

[四]深度学习Pytorch-线性回归

[五]深度学习Pytorch-计算图与动态图机制

[六]深度学习Pytorch-autograd与逻辑回归

[七]深度学习Pytorch-DataLoader与Dataset(含人民币二分类实战)

[八]深度学习Pytorch-图像预处理transforms

[九]深度学习Pytorch-transforms图像增强(剪裁、翻转、旋转)

[十]深度学习Pytorch-transforms图像操作及自定义方法

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

2.2.10 torch.eye(n)

torch.eye(n, m=None, out=None,out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

(1)功能：创建单位对角矩阵（对角线元素为1），2维张量；
(2)注意事项：默认为方针；
(3)参数：
n: 行数；
m: 列数；
(4)代码示例：

c = torch.eye（3）
print(c)

#输出为：
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])

2.3 依概率分布创建张量

2.3.1 torch.normal(mean, std)

torch.normal(mean, std, out=None)
torch.normal(mean, std, size, out=None)

(1)四种模式：mean为标量/张量，std为标量/张量
(2)功能：均值为mean，标准差为std的分布
(3)参数：
mean: 均值
std: 标准差
(4)代码示例：

# ===============================  exmaple 7 ===============================
# 通过torch.normal创建正态分布张量
flag = True
# flag = False
if flag:

    # mean：张量 std: 张量
    # mean = torch.arange(1, 5, dtype=torch.float) #[1,2,3,4]
    # std = torch.arange(1, 5, dtype=torch.float) #[1,2,3,4]
    # t_normal = torch.normal(mean, std)
    # print("mean:{}\nstd:{}".format(mean, std))
    #t_normal输出为[1.6614, 2.5338, 3.1850, 6.4853]
    #1.6614是均值为1标准差为1采样而来，2.5338是均值为2标准差为2采样而来，3.1850是标准差为3采样而来，6.4853是均值为4标准差为4采样而来
    # print(t_normal)

    # mean：标量 std: 标量
    # t_normal = torch.normal(0., 1., size=(4,)) #都是标量时还需要增加size来限定张量的大小
    #t_normal输出为：[0.6614,0.2669,0.0617,0.6213],每一个值都是以均值为0标准差为1进行采样
    # print(t_normal)

    # mean：张量 std: 标量
    mean = torch.arange(1, 5, dtype=torch.float) #[1,2,3,4]
    std = 1
    t_normal = torch.normal(mean, std)
    print("mean:{}\nstd:{}".format(mean, std))
    #t_normal输出为：[1.6614,2.2669,3.0617,4.6213]
    #第一个是以1为均值1为标准差采样，第二个是以2为均值1为标准差采样。
    #第三个是以3为均值1为标准差采样，第四个是以4为均值1为标准差采样。
    print(t_normal)

2.3.2 torch.randn(*size)

torch.randn(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

(1)功能：均值为0，标准差为1的正态分布
(2)代码示例：

torch.randn(4)
#输出
tensor([-2.1436,  0.9966,  2.3426, -0.6366])

torch.randn(2, 3)
#输出
tensor([[ 1.5954,  2.8929, -1.0923],
        [ 1.1719, -0.4709, -0.1996]])

2.3.3 torch.randn_like(input)

torch.randn_like(input, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)

功能：生成数值是标准正态分布(0,1)，大小是input形状的张量

2.3.4 torch.rand(*size)

torch.rand(*size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

(1)功能：生成数值为[0,1)区间上均匀分布，大小为size的张量；
(2)参数：
size: 张量形状；
(3)代码示例：

torch.rand(4)
#输出
tensor([ 0.5204,  0.2503,  0.3525,  0.5673])
torch.rand(2, 3)
#输出
tensor([[ 0.8237,  0.5781,  0.6879],
        [ 0.3816,  0.7249,  0.0998]])

2.3.6 torch.randint(low=0, high, size)

torch.randint(low=0, high, size, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False)

(1)功能：生成数值为[low,high)区间上均匀分布的整数，大小为size的张量；
(2)参数：
size: 张量形状；
(3)代码示例：

torch.randint(3, 5, (3,))
#输出
tensor([4, 3, 4])

torch.randint(10, (2, 2))
#输出
tensor([[0, 2],
        [5, 5]])

torch.randint(3, 10, (2, 2))
#输出
tensor([[4, 5],
        [6, 7]])

2.3.7 torch.randint_like(input, low=0, high)

torch.randint_like(input, low=0, high, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format)

(1)功能：生成数值为[low,high)区间上均匀分布的整数，大小为input形状的张量；
(2)参数：
size: 张量形状；
(3)代码示例：

t1 = torch.randint(1,4,(2,3,2)) #[1,4)均匀分布的整数，大小为2*3*2
t2 = torch.randint_like(t1, 4) #[0,4)均匀分布的整数，大小为t1
print(t1)
"""
tensor([[[2, 2],
         [3, 1],
         [3, 2]],
        [[1, 1],
         [1, 3],
         [2, 2]]])
"""

print(t2)
"""
tensor([[[2, 3],
         [1, 2],
         [0, 2]],
        [[3, 1],
         [1, 1],
         [0, 2]]])
"""

2.3.8 torch.randperm(n)

torch.randperm(n, generator=None, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False, pin_memory=False)

(1)功能：生成0,1,2,...,n-1的随机顺序数列；
torch.randperm(n)常用来生成乱序的索引
(2)参数：
n: 张量的长度；
(3)代码示例：

torch.randperm(4)
#输出
tensor([2, 1, 0, 3])

2.3.9 torch.bernoulli(input)

torch.bernoulli(input, generator=None, out=None)

(1)功能：以input的数值为概率（input数值必须[0,1]区间内），生成伯努利分布（0-1分布，两点分布）的结果构成的张量；
(2)参数：
input: 概率值；
(3)代码示例：

>>> a = torch.empty(3, 3).uniform_(0, 1)  # generate a uniform random matrix with range [0, 1]
>>> a
tensor([[ 0.1737,  0.0950,  0.3609],
        [ 0.7148,  0.0289,  0.2676],
        [ 0.9456,  0.8937,  0.7202]])
>>> torch.bernoulli(a)
tensor([[ 1.,  0.,  0.],
        [ 0.,  0.,  0.],
        [ 1.,  1.,  1.]])

>>> a = torch.ones(3, 3) # probability of drawing "1" is 1
>>> torch.bernoulli(a)
tensor([[ 1.,  1.,  1.],
        [ 1.,  1.,  1.],
        [ 1.,  1.,  1.]])
>>> a = torch.zeros(3, 3) # probability of drawing "1" is 0
>>> torch.bernoulli(a)
tensor([[ 0.,  0.,  0.],
        [ 0.,  0.,  0.],
        [ 0.,  0.,  0.]])