Pytorch基础-01-Pytorch中的Tensor

Tensor在PyTorch中负责存储基本数据，PyTorch 针对Tensor也提供了丰富的方法，PyTorch中的Tensor与NumPy数组具有极高的相似性。

• 1. Tensor的数据类型

(1）torch.FloatTensor：用于生成数据类型为浮点型的Tensor，传 递给torch.FloatTensor的参数可以是一个列表，也可以是一个维度值。

import torch 
a= torch.FloatTensor(2 , 3) 
b = torch.FloatTensor([2 , 3 , 4 , 5]) 
print (a)
print (b)

tensor([[0., 0., 0.],
[0., 0., 0.]])
tensor([2., 3., 4., 5.])

(2)torch.IntTensor：用于生成数据类型为整型的 Tensor，传递给torch.IntTensor的参数可以是一个列表，也可以是一个维度值。

import torch 
a= torch.IntTensor(2 , 3) 
b = torch.IntTensor([2 , 3 , 4 , 5]) 
print (a)
print (b)

tensor([[0, 0, 0],
[0, 0, 0]], dtype=torch.int32)
tensor([2, 3, 4, 5], dtype=torch.int32)

(3)torch.rand：用于生成数据类型为浮点型且维度指定的随机Tensor，和在NumPy中numpy.rand生成随机数的方法类似，随机生成的浮点数据在0～1区间均匀分布。

import torch 
a= torch.rand(2 , 3) 
print (a)

tensor([[0.2286, 0.5715, 0.3911],
[0.9056, 0.9338, 0.6823]])

(4)torch.randn：用于生成数据类型为浮点型且维度指定的随机 Tensor，和在NumPy中使用numpy.randn生成随机数的方法类似，随机生 成的浮点数的取值满足均值为0、方差为1的正太分布。

import torch 
a= torch.randn(2 , 3) 
print (a)
print (a.shape)
print (a.dtype)

tensor([[-0.2607, 0.1303, -0.1775],
[ 1.4425, 1.1204, -1.4925]])
torch.Size([2, 3])
torch.float32

(5)torch.arange：用于生成数据类型为浮点型且自定义起始范围和结束范围的Tensor，所以传递给torch.arange的参数有三个，分别是范 围的起始值、范围的结束值和步长，其中，步长用于指定从起始值到结 束值的每步的数据间隔。

import torch 
a= torch.arange(1,5,1) 
print (a)

tensor([1, 2, 3, 4])

(6)torch.zeros/torch.ones：用于生成数据类型为浮点型且维度指定的Tensor，不过这个浮点型的Tensor中的元素值全部为0。

import torch 
a = torch.zeros(2,3)
b = torch.ones(2,3)
print (a)
print (b)

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

• 2. Tensor的运算

(1)torch.abs：将参数传递到torch.abs后返回输入参数的绝对值作为输出，输入参数必须是一个Tensor数据类型的变量。

import torch 
a = torch.randn(2 , 3) 
print(a) 
b = torch.abs(a) 
print(b) 

tensor([[-2.1963, 1.4662, 0.9466],
[-0.2248, 1.0519, -0.0097]])
tensor([[2.1963, 1.4662, 0.9466],
[0.2248, 1.0519, 0.0097]])

(2)torch.add 将参数传递到 torch.add 后返回输入参数的求和结果作为输出，输入参数既可以全部是 Tensor 数据类型的变 ，也可以 个是 Tensor 数据类型的变 ，另个是标量。

import torch 
a= torch.randn(2 , 3) 
print(a) 
b = torch.randn(2 , 3) 
print (b) 
c = torch.add(a,b) 
print(c) 
d = torch.randn (2 , 3) 
print (d ) 
e = torch.add(d , 10) 
print(e)

tensor([[ 1.2345, -2.1702, 0.3194],
[-1.4653, 0.5673, 0.3822]])
tensor([[-0.7708, 0.9779, -0.1821],
[-0.1279, 0.0275, -2.0093]])
tensor([[ 0.4637, -1.1923, 0.1373],
[-1.5931, 0.5948, -1.6271]])
tensor([[ 0.7965, 0.0319, 0.3526],
[ 0.6700, -1.3297, -0.6916]])
tensor([[10.7965, 10.0319, 10.3526],
[10.6700, 8.6703, 9.3084]])

(3)torch.clamp：对输入参数按照自定义的范围进行裁剪，最后 将参数裁剪的结果作为输出。所以输入参数一共有三个，分别是需要进 行裁剪的Tensor数据类型的变量、裁剪的上边界和裁剪的下边界，具体 的裁剪过程是：使用变量中的每个元素分别和裁剪的上边界及裁剪的下 边界的值进行比较，如果元素的值小于裁剪的下边界的值，该元素就被 重写成裁剪的下边界的值；同理，如果元素的值大于裁剪的上边界的 值，该元素就被重写成裁剪的上边界的值。

import torch 
a= torch.randn(2 , 3 ) 
print(a)
b = torch.clamp(a,-0.1,0.1) 
print(b)

tensor([[ 1.0961, -0.0174, -1.0076],
[ 1.8031, -0.5089, 1.1441]])
tensor([[ 0.1000, -0.0174, -0.1000],
[ 0.1000, -0.1000, 0.1000]])

(4)torch.div：将参数传递到torch.div后返回输入参数的求商结果作为输出，同样，参与运算的参数可以全部是Tensor数据类型的变量， 也可以是Tensor数据类型的变量和标量的组合。

import torch 
a= torch.randn(2 , 3) 
print(a) 
b = torch.randn(2 , 3) 
print(b) 
c = torch.div(a , b) 
print(c) 
d = torch.randn(2 , 3) 
print (d) 
e = torch.div(d, 10) 
print(e)

tensor([[-2.6034, -1.7135, 2.5178],
[-1.2169, 1.3032, 1.1943]])
tensor([[-0.3155, 0.2532, 0.2829],
[-0.6542, 1.1969, -0.2730]])
tensor([[ 8.2529, -6.7682, 8.9012],
[ 1.8601, 1.0888, -4.3742]])
tensor([[-1.2303, 2.6797, 0.6228],
[ 1.6210, 0.3091, -0.0494]])
tensor([[-0.1230, 0.2680, 0.0623],
[ 0.1621, 0.0309, -0.0049]])

(5)torch.mul：将参数传递到 torch.mul后返回输入参数求积的结 果作为输出，参与运算的参数可以全部是Tensor数据类型的变量，也可 以是Tensor数据类型的变量和标量的组合。

import torch 
a= torch.randn(2 , 3) 
print(a) 
b = torch.randn(2 , 3) 
print(b) 
c = torch.mul(a , b ) 
print(c)
d = torch.randn (2 , 3 ) 
print(d) 
e = torch.mul(d , 10) 
print(e )

tensor([[ 0.5125, 1.2539, -0.3695],
[-0.9046, -0.9782, 0.1142]])
tensor([[ 0.4699, -0.0506, -0.2005],
[-0.7670, 2.7568, -0.6387]])
tensor([[ 0.2408, -0.0634, 0.0741],
[ 0.6938, -2.6967, -0.0729]])
tensor([[-0.5776, 0.1463, 1.3700],
[ 0.9351, 0.9319, 2.0941]])
tensor([[-5.7758, 1.4628, 13.7002],
[ 9.3510, 9.3188, 20.9410]])

(6)torch.pow：将参数传递到torch.pow后返回输入参数的求幂结果作为输出，参与运算的参数可以全部是Tensor数据类型的变量，也可以是Tensor数据类型的变量和标量的组合。

import torch 
a = torch.arange( 1,4,1 ) 
print(a) 
b = torch.pow(a , 2) 
print(b)

tensor([1, 2, 3])
tensor([1, 4, 9])

(7)torch.mm：将参数传递到 torch.mm后返回输入参数的求积结果作为输出，不过这个求积的方式和之前的torch.mul运算方式不太一样，torch.mm运用矩阵之间的乘法规则进行计算，所以被传入的参数会 被当作矩阵进行处理，参数的维度自然也要满足矩阵乘法的前提条件， 即前一个矩阵的行数必须和后一个矩阵的列数相等，否则不能进行计算。

import torch 
a= torch.randn(2 , 3) 
print(a) 
b = torch.randn(3 , 2) 
print(b)
c = torch.mm(a , b) 
print(c )

tensor([[ 0.3215, -0.2299, -1.0204],
[ 0.6271, -0.6563, 0.1244]])
tensor([[-0.9333, 1.1577],
[-1.7651, 1.7631],
[ 0.5557, -0.7709]])
tensor([[-0.4613, 0.7535],
[ 0.6422, -0.5269]])

(8)torch.mv：将参数传递到torch.mv后返回输入参数的求积结果 作为输出，torch.mv运用矩阵与向量之间的乘法规则进行计算，被传入 的参数中的第1个参数代表矩阵，第2个参数代表向量，顺序不能颠倒。

import torch 
a= torch.randn(2 , 3) 
print(a) 
b = torch.randn(3) 
print(b) 
c = torch.mv(a , b)
print (c)

tensor([[ 0.2336, 0.7414, 0.9811],
[ 1.8873, -1.7557, -0.0469]])
tensor([ 0.1852, -2.3270, 0.5554])
tensor([-1.1370, 4.4090])

• 3. 搭建一个简单神经网络

我们先通过import torch导入必要的包，然后定义4个整型变量，其 中：batch_n是在一个批次中输入数据的数量，值是100，这意味着我们 在一个批次中输入100个数据，同时，每个数据包含的数据特征有 input_data个，因为input_data的值是1000，所以每个数据的数据特征就 是1000个；hidden_layer用于定义经过隐藏层后保留的数据特征的个 数，这里有100个，因为我们的模型只考虑一层隐藏层，所以在代码中 仅定义了一个隐藏层的参数；output_data是输出的数据，值是10，我们 可以将输出的数据看作一个分类结果值的数量，个数10表示我们最后要 得到10个分类结果值。
一个批次的数据从输入到输出的完整过程是：先输入100个具有 1000个特征的数据，经过隐藏层后变成100个具有100个特征的数据，再 经过输出层后输出100个具有10个分类结果值的数据，在得到输出结果 之后计算损失并进行后向传播，这样一次模型的训练就完成了，然后循 环这个流程就可以完成指定次数的训练，并达到优化模型参数的目的。

import torch

batch_n = 100
hidden_layer = 100
input_data = 1000
output_data = 10

x = torch.randn(batch_n, input_data)
y = torch.randn(batch_n, output_data)

w1 = torch.randn(input_data, hidden_layer)
w2 = torch.randn(hidden_layer, output_data)

epoch_n = 20
learning_rate = 1e-6

for epoch in range(epoch_n):
    h1 = x.mm(w1)
    h1 = h1.clamp(min=0)
    y_pred = h1.mm(w2)

    loss = (y_pred - y).pow(2).sum()
    print('Epoch:{},Loss:{}'.format(epoch, loss))

    grad_y_pred = 2 * (y_pred - y)
    # torch.t()转置
    grad_w2 = h1.t().mm(grad_y_pred)

    grad_h = grad_y_pred.clone()
    grad_h = grad_h.mm(w2.t())
    grad_h.clamp_(min=0)
    grad_w1 = x.t().mm(grad_h)

    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

Epoch:0,Loss:66540424.0
Epoch:1,Loss:191525728.0
Epoch:2,Loss:578822720.
Epoch:3,Loss:433607648.
Epoch:4,Loss:3088475.75
Epoch:5,Loss:2690726.0
Epoch:6,Loss:2393706.
Epoch:7,Loss:2157809.
Epoch:8,Loss:1963085.375
Epoch:9,Loss:1797485.875
Epoch:10,Loss:1654117.5
Epoch:11,Loss:1528636.375
Epoch:12,Loss:1417824.0
Epoch:13,Loss:1319089.
Epoch:14,Loss:1230564.875
Epoch:15,Loss:1150966.75
Epoch:16,Loss:1079071.
Epoch:17,Loss:1013925.
Epoch:18,Loss:954534.2
Epoch:19,Loss:900352.4375