测试环境版本:
torch1.7.1 + CPU

python 3.6

一、线性代数

import torch as t

a = t.arange(0,9).view(3,3)
b = t.arange(0,12).view(3,4)

求矩阵的迹(主对角线元素之和)

print(a)
a.trace()

tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])





tensor(12)

print(b)
b.trace()

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])





tensor(15)

非方阵也可以求迹！
取主对角线元素

b.diag()

tensor([ 0,  5, 10])

包含了矩阵的所有常用操作,使用时再百度吧。

注意矩阵存储的连续性问题:

当取转置后，矩阵的存储就不再连续。

b = b.t()

b

tensor([[ 0,  4,  8],
        [ 1,  5,  9],
        [ 2,  6, 10],
        [ 3,  7, 11]])

当矩阵的存储不再连续之后，某些函数就不能正常使用，比如view方法。下面注释掉的代码会报错

需要使用contiguous()方法使矩阵连续存储

# b.view(3,4)

b.contiguous().view(3,4)

tensor([[ 0,  4,  8,  1],
        [ 5,  9,  2,  6],
        [10,  3,  7, 11]])

二、Tensor与Numpy

tensor与numpy的转化共享内存，简单高效。两者可以相互转化来灵活使用

import numpy as np
a = np.ones([2,3],dtype=np.float32)
a

array([[1., 1., 1.],
       [1., 1., 1.]], dtype=float32)

b = t.from_numpy(a)
b

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

也可以用b = t.Tensor(a)创建，但假如a不是float32型，b会新建一个张量。

tip:尽量避免for循环，而是要采用内建的函数。

• 这些内建函数算法很高效
• 很多函数底层是用C++写的，速度远高于python

  三、实践：线性回归

  我们要求的方程形式为: $y=wx+b+e$
  其中e为正态分布的误差。
  
  损失函数采用均方误差

import torch as t
%matplotlib inline
from matplotlib import pyplot as plt
from IPython import display

t.manual_seed(1000)# 设置随机数种子，保证代码在不同计算机上运行结果相同
def get_data(batch_size=8):
    x = t.rand(batch_size,1)*20
    y = x * 2 + (1 + t.randn(batch_size,1)) * 3
    return x , y
# 模拟的是y = 2x + 3,只是增加了噪声

x,y = get_data()

plt.scatter(x.squeeze().numpy(),y.squeeze().numpy())

<matplotlib.collections.PathCollection at 0x151ef632908>

#初始化权重参数
w = t.rand(1,1)
b = t.zeros(1,1)
lr = 0.001 # 学习率
for i in range(20000):
    x,y = get_data()
    # 前向传播
    y_pred = x.mm(w) + b.expand_as(y) # tensor.mm是矩阵乘法
    loss = 0.5 * ((y_pred - y) ** 2) # 均方误差，loss是一个1*8的矩阵
    loss = loss.sum()
    dy_pred = y_pred - y # 这里是不严谨地求梯度
    dw = x.t().mm(dy_pred)
    db = dy_pred.sum()

    # 更新参数

    w.sub_(lr*dw)
    b.sub_(lr*db)
print(w)
print(b)

tensor([[2.0513]])
tensor([[3.0743]])

拟合效果比较好！