深度学习——基本数据类型创建Tensor（持续更新）-编程知识

声明：本深度学习笔记基于课时18 索引与切片-1_哔哩哔哩_bilibili学习而来

All is about Tensor

定义：Tensors are simply mathematical objects that can be used to describe physical properties, just like scalars and vectors. In fact tensors are merely a generalisation of scalars and vectors; a scalar is a zero rank tensor, and a vector is a first rank tensor.

这句话的大概意思就是张量就是标量和向量的推广，标量被称为0维张量，向量被称为一维张量。

我们先将python常用的数据类型和pytorch进行比较，我们可以很清楚的看出pytorch的数据类型都加了一个张量（Tensor），但是pytorch里面并没有字符串类型，因为pytorch主要是一个关于计算的库。

但是，我们在pytorch里面就用不到字符串吗？当让不是，在数字识别体验课的时候我们是用了One-hot的编码方式，就是我们创建一个长度为10的一维向量，如果对应上了，我们就把与此对应的数值改为1。

问题又来了，我们需要处理的数据太过庞大了，比如我们处理10万个数据，我们还要使用长度为10万的向量吗？答案，肯定不是。我们使用叫做Embedding的编码方式。

总的来说，就是讲pytorch使用编码的方式处理字符串。

再回到我们的数据类型上：

我们在pytorch上使用torch.FloatTensor表示浮点型，其它类型同理。众所周知，深度学习需要处理大量的数据，需要大量的计算，为了提高效率，我们让GPU帮助我们计算，但是此时数据类型就要加上cuda了。

Type check

import torch
a = torch.randn(2,3)                # 创建一个2*3矩阵print("Tensor:",a)
# 输出：Tensor: tensor([[-0.6643, -1.7207, -0.7312],
#        [-0.9627, -0.5519, -0.7359]])print("Tensor of type:",a.type())
# 输出：Tensor of type: torch.FloatTensor# 在深度学习中，我们经常会用到参数的合理化检验，一般使用下面这个方法
isinstance(a,torch.FloatTensor)
# 输出：Ture# 不常使用的
# print(type(a))

再讲述一下pytorch默认类型的问题，以及设置默认类型的问题：

pytorch中使用tensor创建的张量默认类型为双精度类型

print(torch.tensor([1.2,3]).type())
# out：torch.DoubleTensor
# 设置默认类型：
torch.set_default_tensor_type(torch.FloatTensor)
print(torch.tensor([1.2,3]).type())
# out：torch.FloatTensor

dim

注：tensor里面包含的就是具体的数据。

size()&shape&dim()

我觉得进行下面的学习之前，应该先搞明白size，shape，dim的概念。

shape是一个属性，在使用的时候不用加括号；size()是一个方法。其实shape和size()的作用是一样的，但是shape是numpy中array和pytorch中的tensor通用的size()只能用在tensor上。

dim()方法是计算维度的，效果和len(a.shape)一样。

a = torch.tensor([[1,2,3,0],[4,5,7,9],[7,8,5,3]])
print("shape:",a.shape)
# out:shape: torch.Size([3, 4])
print("dim：",a.dim())
# out:dim： 2
print("size:",a.size())
# out:size: torch.Size([3, 4])

创建Tensor

1、import from numpy

# 创建Tensor
# eg1
import numpy as np
a = np.array([2,3.3])           # 先使用numpy创建dim 1  size 2 的向量
print(torch.from_numpy(a))      # 导入 
# out：tensor([2.0000, 3.3000])
#eg2
a = np.ones([2,3])              # 先使用np直接创建一个维度为2，size为3的向量
print(torch.from_numpy(a))
# out：tensor([[1., 1., 1.],
#         [1., 1., 1.]])

2、import from List

当时数据量不是很大的时候就可以使用此方法。直接使用List方法tensor接受现有数据，Tensor接受数据的维度，也可以接受现有数据。

print(torch.tensor([2.,3.2]))
# out：tensor([2.0000, 3.3000])
print(torch.tensor([[2.,3.2],[1.,22.369]]))
# out：tensor([[ 2.0000,  3.2000],
#         [ 1.0000, 22.3690]])
print(torch.FloatTensor([2.,3.2]))              # 接收数据
# out：tensor([2.0000, 3.3000])
print(torch.FloatTensor(2,3))                   # 接受维度
# out：tensor([[-2.9315e-03,  1.0272e-42, -1.5882e-23],
#         [ 2.1500e+00,  0.0000e+00,  1.8750e+00]], dtype=torch.float32)
print(torch.Tensor([2.,3.2]))
# out：tensor([2.0000, 3.3000])

但是一般在使用的时候会使用 tensor专门接受现有数据，Tensor专门接受数据的维度，这样不容易搞混。

3、uninitialized

当需要未初始化数据的时候可以使用以下几种方法。

# 以下方法生成的数据非常的不规律，需要使用数据进行覆盖
print(torch.empty(2))              # 生成一个未初始化长度为1的数据
# out：tensor([1.2697e-321, 4.9407e-324])
print(torch.Tensor(2,3))
# out：tensor([[4.9407e-324, 4.9407e-324, 4.9407e-324],
#         [4.9407e-324, 4.9407e-324, 4.9407e-324]])
print(torch.IntTensor(2,3))
# out：tensor([[-1153427456,         733,   -81441600],
#         [ 1072143930,  -588085446,  1071206672]], dtype=torch.int32)
print(torch.FloatTensor(2,3))
# out：tensor([[-2.9309e-03,  1.0272e-42, -8.5829e+35],
#         [ 1.8095e+00, -5.4613e+17,  1.6978e+00]], dtype=torch.float32)

4、rand/rand_like,randint

随机初始化，也是推荐最常使用的。

print(torch.rand(3,3))              # rand()方法随机产生0-1的数据，此时产生一个3*3的二维张量（第一维长度为3，第二维长度为3）
# out：tensor([[0.0664, 0.6562, 0.3293],
#         [0.4063, 0.8417, 0.0114],
#         [0.0279, 0.3318, 0.5429]])
a = torch.rand(3,3)
print(torch.rand_like(a))           # 作用：接受的是一个shape，会将a的shape直接读出来，再传入rand()方法
# out：tensor([[0.5812, 0.8895, 0.3767],
#         [0.3151, 0.2174, 0.5673],
#         [0.4537, 0.9913, 0.7640]])
print(torch.randint(1,10,[3,3]))    # randint()方法只能随机产生整数，此时产生一个所有元素都位于1-10的3*3的二维张量
# out：tensor([[7, 1, 3],
#         [2, 2, 8],
#         [2, 8, 6]])

如果想要均匀采样0-10的tensor，要使用x = 10*torch.rand(d1,d2)，randint()只能采样整数。

5、randn

会产生正态0，1分布的随机数。

print(torch.randn(3,3))
# out：tensor([[ 0.9438,  0.8224, -0.9046],
#         [-0.0314,  1.2954, -0.6943],
#         [ 1.0301, -0.3824, -1.0747]])
print(torch.normal(mean=torch.full([10],0.), std=torch.arange(1,0,-0.1)))
# out：tensor([-0.4060, -0.5174,  0.1747, -0.7274, -0.0309,  0.4580, -0.6965, -0.2976,
#         -0.1198,  0.0581])

normal(mean, std, *, generator=None, out=None)

返回值：一个张量，张量中每个元素是从相互独立的正态分布中随机生成的。每个正态分布的均值和标准差对应着mean中的一个值和std中的一个值。

注意：张量mean和std的形状不一定相同，但是元素个数必须相同。如果二者形状不一致，返回张量的形状和mean的一致

generator=None：用于采样的伪随机数发生器

out：输出张量的形状

6、full

print(torch.full([2,3],7))      # 创建一个全为7的2*3二维向量
# out：tensor([[7, 7, 7],
#         [7, 7, 7]])
print(torch.full([],7))         # 创建一个全为7的标量
# out：tensor(7)
print(torch.full([2],7))        # 创建一个全为7的1*2一维向量
# out：tensor([7, 7])

7、arange/range

生成递增、递减等差数列的API。

print(torch.arange(0,10))       # 生成一个从0开始，不到10的等差数列
# out：tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print(torch.arange(0,10,2))
# out：tensor([0, 2, 4, 6, 8])
print(torch.range(0,10))        # 不推荐使用这个
# out：tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
# C:\Users\Lenovo\AppData\Local\Temp\ipykernel_10204\2132562954.py:3: UserWarning: torch.range is deprecated and will be removed in a future release because its behavior is inconsistent with Python's range builtin. Instead, use torch.arange, which produces values in [start, end).
#   print(torch.range(0,10))

8、linspace/logspace

生成一个等差的数列。

print(torch.linspace(0,10,steps=4))         # 后面的数是指生成元素的个数
# out：tensor([ 0.0000,  3.3333,  6.6667, 10.0000])
print(torch.linspace(0,10,steps=10))
# out：tensor([ 0.0000,  1.1111,  2.2222,  3.3333,  4.4444,  5.5556,  6.6667,  7.7778,
#          8.8889, 10.0000])
print(torch.linspace(0,10,steps=11))
# out：tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
print(torch.logspace(0,-1,steps=10))        # 生成10个10的0次方到10的-1次方的数
# out：tensor([1.0000, 0.7743, 0.5995, 0.4642, 0.3594, 0.2783, 0.2154, 0.1668, 0.1292,
#         0.1000])
print(torch.logspace(0,1,steps=10))
# out：tensor([ 1.0000,  1.2915,  1.6681,  2.1544,  2.7826,  3.5938,  4.6416,  5.9948,
#          7.7426, 10.0000])

9、Ones/zeros/eye

生成全0，全1，是对角矩阵的。

print(torch.ones(3,3))      # 生成一个全一3*3的二维张量
# out：tensor([[1., 1., 1.],
#              [1., 1., 1.],
#              [1., 1., 1.]])
print(torch.zeros(3,3))     # 生成一个全零3*3的二维张量
# out：tensor([[0., 0., 0.],
#             [0., 0., 0.],
#             [0., 0., 0.]])
print(torch.eye(3,4))       # 生成一个近似对角矩阵
# out：tensor([[1., 0., 0., 0.],
#         [0., 1., 0., 0.],
#         [0., 0., 1., 0.]])
print(torch.eye(3))         # 生成一个对角矩阵
# out：tensor([[1., 0., 0.],
#         [0., 1., 0.],
#         [0., 0., 1.]])
a=torch.zeros(3,3)
print(torch.ones_like(a))
# out：tensor([[1., 1., 1.],
#         [1., 1., 1.],
#         [1., 1., 1.]])

10、randperm

随机打散

print(torch.randperm(10))       # 随机生成一个0-9长度为10的索引
a=torch.rand(2,3)
b=torch.rand(2,2)
idx=torch.randperm(2)
print(idx)
print(idx)
print(a[idx])                   # 这个必须和下面一句idx保持一致
print(b[idx])
print(a,b)

补充

如果a=tensor([[[0.0787, 0.8906, 0.0690], [0.1323, 0.5660, 0.2708]]])，a[0] = tensor([[0.0787, 0.8906, 0.0690], [0.1323, 0.5660, 0.2708]])，获取a中第0个元素，就是第一维度的第0个元素；a[0][0]=tensor([0.0787, 0.8906, 0.0690])，获取a中第二维度的第0个元素的第0个元素。

a = torch.randn(2,3)
print(a)
# out:tensor([[ 1.7312,  1.8919,  0.3483],
#         [ 0.6409,  1.5857, -1.4704]])
print(a.shape)          # 获取tensor的具体形状
# out:torch.Size([2, 3])
print(a.size(0))        # 获取shape的第0个元素
# out:2
print(a.size(1))        # 获取shape的第1个元素
# out:3
print(a.shape[1])       # 获取shape的第1个元素，但是注意括号的区别
# out:3

tensorData.numel()  # 具体占用内存大小