Pytorch笔记 (3) 科学计算1

 一、张量

标量 可以看作是  零维张量

向量 可以看作是  一维张量

矩阵 可以看作是  二维张量

继续扩展数据的维度，可以得到更高维度的张量 ————>  张量又称 多维数组

给定一个张量数据，就可以确定 它的维度 + 大小 + 元素个数

# 对于一个 大小为 0个条目的元组（） ，元素个数为1

只有 维度、大小、元素个数、各元素都相同的两个张量，才是两个相同的张量

举例：
对于某个张量，若其中有个条目是 1，那么这个1不可省略。也应该算进张量的维度中。
大小为（3，1） 的二维张量 和 大小为 （3，）的张量虽然有着相同的元素个数，但是它们的维度不同，大小不同 ————>  不是相同的张量

 # 一维张量的大小具有 (s[0],) 的形式，而不是 (s[0],1) 或 (1,s[0]) 的形式。一维张量和向量同构，但严格意义上斌不是向量，也就没有 “行（列）向量”的说法。

（1）Pytorch 中的张量

 在Pytorch 中，张量是运算的基本数据类型,用类  torch.Tensor  实现。

import torch
t2 = torch.tensor([[0,1,2],[3,4,5]])  #将一个列表 转换成torch.Tensor 类  实例t2  【即张量t2】
print(t2)
print('数据 = {}'.format(t2))
print(t2.reshape(3,2))  #重新组织元素   【使其大小从（2，3）变为（3，2）】
print(t2 + 1)   #逐 元素运算  【利用张量 进行数学计算，进行逐元素+1，得到新的张量】

 在Pytorch 中，可以通过torch.Tensor类 实例的成员获得性质 ————  张量的大小、维度、元素个数

print('数据 = {}'.format(t2))
print('大小 = {}'.format(t2.size()))
print('维度 = {}'.format(t2.dim()))
print('元素个数 = {}'.format(t2.numel()))

 另外，每个张量类实例还会有元素类型 （dtype）:

可以通过张量类实例的成员 dtype 查看元素类型：

print('元素类型 = {}'.format(t2.dtype))

结果：

元素类型 = torch.int64

上述代码在构造 torch.Tensor类实例是，使用了int 值列表————>  张量的数据类型默认是 torch.int64型

如果用 bool 值构造，则构造出来的张量元素类型默认是————>  torch.uint8型

如果用float值构造————>  torch.float32型

二、构造torch.Tensor类实例

 使用以下函数来构造torch.Tensor类实例

（1）构造含有特定数据的张量

torch.tensor()

t0 = torch.tensor(0)
t1 = torch.tensor([0.,1.,2.])
t2 = torch.tensor([[[0.,1.,2.],[3.,4.,5.],[6.,7.,8.]],[[9.,10.,11.],[12.,13.,14.],[15.,16.,17.]],[[18.,19.,20.],[21.,22.,23.],[24.,25.,26.]]])

 利用该函数构造了张量 t0,t1,t2 ,t3 ,在张量的构造语句中，使用了列表作为参数

由于参数列表中的数据都是浮点数，所以这些张量的元素类型都是 torch.float32

torch.tensor()的关键字参数 dtype ———— 用来指定张量的元素类型

# 如果没有这个关键字参数，张量的元素类型是从 列表元素 推到而来的【bool —— torch.uint8;   int —— torch.int64;   float —— torch.float32】

t_int8 = torch.tensor([1,2],dtype=torch.int8)

(2)构造特定大小的张量

torch.zeros()  torch.ones()   torch.empty 函数可以使用多个int 类型的参数来构造给定类型的变量

要想用这些函数构造n维张量，就要传入n个整数，这n个整数就是张量大小的n个条目，用此方法，可以不指定张量中元素的值，也可以指定张量中元素的值为相同值。

如果不指定张量中元素的值，可以用 torch.empty() 函数 ———— 构造出来的张量的元素值 是不确定的！

如果要指定张量中元素的值，可以用 torch.zeros() torch.ones() —— 指定代码中的元素均为 0/1

可以用 torch.full() 将元素初始化为0 1 以外的值 ———— 需要两个不同的参数 ———— 张量大小和 要填充的值

t1 = torch.empty(2)  #未初始化
print(t1)
t2 = torch.zeros(2,2)   #各元素值为 0
print(t2)
t3 = torch.ones(2,2,2)   #各元素值 为1
print(t3)
t4 = torch.full((2,2,2,2),3.)  #各元素值为3
print(t4)

tensor([0., 0.])
tensor([[0., 0.],
        [0., 0.]])
tensor([[[1., 1.],
         [1., 1.]],

        [[1., 1.],
         [1., 1.]]])
tensor([[[[3., 3.],
          [3., 3.]],

         [[3., 3.],
          [3., 3.]]],


        [[[3., 3.],
          [3., 3.]],

         [[3., 3.],
          [3., 3.]]]])

 上述4个函数都有对应的 torch.*_like（） 形式 ———— 构造一个和现有张量一样大小的张量

tt = torch.ones_like(t2)
print(tt)

tensor([[1., 1.],
        [1., 1.]])

(3)构造等比 等差数列张量

等差数列：

 torch.arange()  构造等差 ———— 需要指定 数列的开始元素 start【含，默认0】,结束元素 end【不含】,和公差step

得到的数列包括start 但不包括end，数列的长度为 [ (end - start ) / step ] 

torch.range() 函数 可以得到长度为 [ (end - start ) /  step  + 1 ] 的等差数列

以下代码可得到： 大小为(4,) ，元素都是 0,1,2,3这四个数的张量

a1 = torch.arange(0,4,step=1)
a2 = torch.range(0,3,step=1)
print(a1)
print(a2)

tensor([0, 1, 2, 3])
tensor([0., 1., 2., 3.])

 构造等差数列 还可以使用 torch.linspace() 函数 ———— 前两个参数为数列 最开始的 和 最后的数 ，steps 指数列中一共有几个数

a3 = torch.linspace(0,3,steps=4)
print(a3)

tensor([0., 1., 2., 3.])

等比数列：

torch.logspace() ———— 前两个参数 经过 10^x 的运算后，才是数列最开始的数 和最后的数，steps 指数列一共有几个数

a4 = torch.logspace(0,3,steps=4)
print(a4)

tensor([   1.,   10.,  100., 1000.])

(4) 构造随机张量

概率分布 分为： 离散概率分布 + 连续概率分布

1. 离散概率分布得到的样本一般是 0 1 这样的整数值
2. 连续概率分布得到的样本一般是 浮点数

离散随机张量的构造：

 

连续随机张量：

 

 

【这块看的挺懵逼的.....所以就直接把书上的弄过来...后期直接查用。。。先学后面的，到后期再回顾这块】