深度学习笔记 —— 线性代数

线性代数实现：

1.标量由只有一个元素的的张量表示

import torch

x = torch.tensor([3.0])
y = torch.tensor([2.0])

2.可以将向量视为标量值组成的列表

x = torch.arange(4)

# 通过张量的索引来访问任一元素
x[3]

3.访问张量的长度

x = tensor.arange(4)
len(x)

Output:
4

只有一个轴的张量，形状只有一个元素

x.shape

Output:
torch.Size([4])

4.通过指定两个分量m和n来创建一个形状为m x n的矩阵

A = torch.arange(20).reshape(5, 4)
print(A)

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15],
        [16, 17, 18, 19]])

矩阵的转置

print(A.T)

tensor([[ 0,  4,  8, 12, 16],
        [ 1,  5,  9, 13, 17],
        [ 2,  6, 10, 14, 18],
        [ 3,  7, 11, 15, 19]])

5.就像向量是标量的推广， 矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构

X = torch.arange(24).reshape(2, 3, 4)
print(X)

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]]])

6.给定具有相同形状的任何两个张量，任何按元素二元运算的结果都将是相同形状的张量

7.两个矩阵的按元素乘法称为哈达玛积（Hadamard product）

A * B

8.计算其元素的和

x = torch.arange(4, dtype=torch.float32)
print(x)
print(x.sum())

Output:
tensor([0., 1., 2., 3.])
tensor(6.) # x.sum()的结果是一个标量

表示任意形状张量的元素和

A = torch.arange(20 * 2).reshape(2, 5, 4)
print(A.shape)
print(A.sum())

Output:
torch.Size([2, 5, 4])
tensor(780)

指定求和，汇总张量的轴

A = torch.arange(20 * 2).reshape(2, 5, 4)
print(A)

# 2, 5, 4分别表示通道，行数，列数
# axis = 0，表示按照通道合并
A_sum_axis0 = A.sum(axis=0)
print(A_sum_axis0)
print(A_sum_axis0.shape)

# axis = 1，表示按行合并
A_sum_axis1 = A.sum(axis=1)
print(A_sum_axis1)
print(A_sum_axis1.shape)

# axis = 2，表示按列合并
A_sum_axis2 = A.sum(axis=2)
print(A_sum_axis2)
print(A_sum_axis2.shape)

# 两个维度求和
A_sum_axis01 = A.sum(axis=[0, 1])
print(A_sum_axis01)
print(A_sum_axis01.shape)

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, 27],
         [28, 29, 30, 31],
         [32, 33, 34, 35],
         [36, 37, 38, 39]]])

tensor([[20, 22, 24, 26],
        [28, 30, 32, 34],
        [36, 38, 40, 42],
        [44, 46, 48, 50],
        [52, 54, 56, 58]])
torch.Size([5, 4])

tensor([[ 40,  45,  50,  55],
        [140, 145, 150, 155]])
torch.Size([2, 4])

tensor([[  6,  22,  38,  54,  70],
        [ 86, 102, 118, 134, 150]])
torch.Size([2, 5])

tensor([180, 190, 200, 210])
torch.Size([4])

9.一个与求和相关的量是平均值（mean或average）

A.mean()
A.sum() / A.numel()

# 按照某一个维度来算均值
A.mean(axis=0)
A.sum(axis=0) / A.shape[0]

10.计算总和或均值时保持轴数不变

# 正常情况下，如果我们按照某一个维度来求和，得到的结果会讲该维度丢失掉
# keepdims=True会使该维度变为1，这样可以通过广播机制使得A除以sum_A
sum_A = A.sum(axis=1, keepdims=True)
print(A / sum_A)

11.某个轴计算A元素的累积总和

A.cumsum(axis = 0)

12.点积是相同位置的按元素乘积的和

y = torch.ones(4, dtype=torch.float32)
x, y, torch.dot(x, y)

我们可以通过执行按元素乘法，然后进行求和来表示两个向量的点击

torch.sum(x * y)

13.矩阵向量积Ax是一个长度为m的列向量，其元素是点积x

torch.mv(A, x) # mv: matrix-vector multiplication

14.可以将矩阵-矩阵乘法AB看作是简单地执行m次矩阵-向量积，并将结果拼接在一起，形成一个n x m矩阵

torch.mm(A, B) # mm: matrix-matrix multiplication

15.范数是向量元素平方和的平方根：

u = torch.tensor([3.0, -4.0])
print(torch.norm(u))

Output:
tensor(5.)

16.范数表示为向量元素的绝对值之和：

torch.abs(u).sum()

17.矩阵的弗罗贝尼乌斯范数（Frobenius norm)是矩阵元素的平方和的平方根：

print(torch.ones((4, 9)))
print(torch.norm(torch.ones((4, 9))))

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