由浅入深，走进深度学习（4）

各位小伙伴大家好，这期内容是深度学习基础的一个进阶，也可以说是夯实一下很多细节内容

个人感受：动手敲一遍，带着思考，会有不一样的感受！！！

代码是比较多的，有很多内容我也是都在代码上面注释了~

正片开始！！！

首先，机器学习用的最多的是N维数组，N维数组是机器学习和神经网络的主要数据结构

注：

创建数组需要 形状(3×4) 数据类型(浮点数32位) 元素值(随机数)
访问元素 根据切片或者间隔步长访问元素  such as [::3, ::2] 每隔3行 2列 访问
访问 一个元素 [1, 2] 一行 [1, :] 一列 [:, 1] 子区域 [1:3, 1:]
张量数据操作

import torch
input = torch.arange(12) # 初始化一个0-11张量
print(input)

# 访问张量形状
print(input.shape)

# 张量中元素总数
print(input.numel())

# 改变张量形状
input_reshape = input.reshape(3, 4) # 一维张量改为3行 4列张量
print(input_reshape)

# 创建全0 全1 张量
zero = torch.zeros(2, 3, 4)
print(zero)

one = torch.ones(2, 3, 4)
print(one)

# 创建特定值张量
tensor1 = torch.tensor([[1, 2, 3],
                        [2, 1, 5],
                        [1, 5, 3]]) # 二维 tensor
tensor2 = torch.tensor([[[2, 2, 5],
                         [1, 3, 2],
                         [1, 2, 4]]]) # 三维 tensor

print(tensor1.shape)
print(tensor2.shape)

张量运算操作
常见的标准算术运算符(+、-、*、/、和 **)都可以被升级为按元素运算

import torch
input1 = torch.tensor([1.0, 2, 4, 8])
input2 = torch.tensor([2, 2, 2, 2])
print(input1 + input2)
print(input1 - input2)
print(input1 * input2)
print(input1 / input2)
print(input1 ** input2) # 运算符是求幂运算

# 对每个元素应用更多的计算
output = torch.exp(input1) # e的x次方
print(output)

# 张量合并操作
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
y = torch.tensor([[1, 2, 3, 2],
                  [0.5, 4, 6, 3.0],
                  [2, 1, 1, 0]])
m = torch.cat((x, y), dim = 0) # 按行拼
n = torch.cat((x, y), dim = 1) # 按列拼

print(m)
print(n)


# 张量逻辑符运算
# 通过逻辑运算符构建二元张量
import torch
x = torch.arange(12, dtype = torch.float32).reshape(3, 4)
y = torch.tensor([[1, 2, 3, 2],
                  [0.5, 4, 6, 3.0],
                  [2, 1, 1, 0]])
print(x, y)
print(x == y) # 对应元素相等为True 不相等为False


# 张量累加运算
import torch
x = torch.arange(16, dtype = torch.float32).reshape(4, 4)
print(x.sum())

# 张量广播运算
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
print(a, b)
print(a + b) # a会复制出一个3*2的矩阵，b复制出一个3*2的矩阵，然后再相加，会得到一个3*2矩阵  

张量访问计算
可以用[-1]选择最后一个元素，可以用[1:3]选择第二个和第三个元素

import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
print(x)
print(x[-1])
print(x[1:3])

# 张量元素改写
# 除读取外，还可以通过指定索引来将元素写入矩阵
import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
print(x)
x[1, 2] = 9
print(x)

# 为多个元素赋值相同的值，只需要索引所有元素，然后为它们赋值
import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
print(x)
x[0:2, :] = 12  # 0:2 第一个 第二个 0:3 第一个 第二个 第三个 1:3 第二个 第三个 1:4 第二个 第三个 第四个
print(x)


# 张量内存变化
# 运行一些操作可能会导致为新结果分配内容
import torch
x = torch.arange(12, dtype = torch.float32).reshape((3, 4))
y = torch.tensor([[1, 1, 2, 2],
                  [2, 2, 3, 3],
                  [4, 4, 2, 3]])
before = id(y)
print(before)
y = x + y
print(id(y) == before) # 运行操作后，赋值后的y的id和原来的id不一样   

z = torch.zeros_like(y) # z 的数据类型、尺寸和y一样，里面的元素全为0

print('id(z):', id(z))
z[:] = x + y
print('id(z):', id(z))

# 如果在后续计算中没有重复使用X，即内存不会过多复制，也可以使用X[:] = X + Y 或 X += Y 来减少操作的内存开销
before1 = id(x)
x += y
print(id(x) == before1)

# 张量转numpy
import torch
x = torch.arange(16, dtype = torch.float32).reshape((4, 4))
a = x.numpy()
b = torch.tensor(a)
print(type(a), a)
print(type(b), b)


# 将大小为1的张量转为 Python 标量
import torch
a = torch.tensor([3.5])
print(a)
print(a.item())
print(float(a))
print(int(a))

线性代数
标量
标量由只有一个元素的张量表示

import torch
x = torch.tensor([3.5])
y = torch.tensor([4.0])
print(x + y)
print(x - y)
print(x * y)
print(x / y)
print(x ** y)

# 访问向量元素
# 通过张量的索引来访问任一元素
import torch
z = torch.arange(12)
print(z)
print(z[3]) # 索引从0开始

# 访问向量长度
# 访问张量长度
print(len(z))

# 访问向量维度
# 只有一个轴的张量形状只有一个元素
print(z.shape)

# 矩阵
# 创建矩阵
# 通过指定两个分量m n 来创建一个形状为m×n的矩阵
import torch
A = torch.arange(20).reshape((4, 5))
print(A)

# 矩阵的转置
print(A.T)

# 对称矩阵
# 对称矩阵 等于其转置
B = torch.tensor([[1, 2, 3],
                  [2, 0, 4],
                  [3, 4, 5]])
print(B)
print(B.T)
print(B == B.T)

# 多维矩阵
# 就像向量是标量的推广 矩阵是向量的推广一样 可以构建更多轴的数据结构
D = torch.arange(24).reshape((2, 3, 4))
print(D)


# 矩阵克隆
import torch
x = torch.arange(20, dtype = torch.float32).reshape((4, 5))
y = x.clone() # 通过分配新内存 将x的一个副本分配给y
print(x)
print(y)
print(x + y)


# 矩阵相乘 对应元素相乘
# 两个矩阵按元素乘法称为哈达玛积
import torch
A = torch.arange(20, dtype = torch.float32).reshape((5, 4))
B = A.clone()
print(A)
print(B)
print(A * B)

# 矩阵加标量
x = 2
A = torch.arange(24).reshape((2, 3, 4))
print(A)
print(A + x)
print((A + x).shape)

# 向量求和
# 计算所有元素的和
M = torch.arange(4, dtype = torch.float32)
print(M)
print(M.sum())

# 矩阵求和
# 表示任意形状张量的元素和
N = torch.arange(20 * 2).reshape((2, 4, 5))
print(N.shape)
print(N.sum())

# 矩阵某轴求和 维度丢失
# 指定张量沿哪一个轴来通过求和降低维度
N_sum_axis0 = N.sum(axis = 0) #(2, 4, 5) 对第一个维度进行求和 剩下两个维度留下来
print('-------------------')
print(N)
print(N_sum_axis0)
print(N_sum_axis0.shape)
N_sum_axis1 = N.sum(axis = 1) #(2, 4, 5) 对第二个维度进行求和 剩下两个维度留下来
print('-------------------')
print(N_sum_axis1)
print(N_sum_axis1.shape)
N_sum_axis2 = N.sum([0 ,1]) #(2, 4, 5) 对第一 二个维度进行求和 剩下一个维度留下来
print('--------------------')
print(N_sum_axis2)
print(N_sum_axis2.shape)



# 矩阵平均值
# 一个与求和相关的量是平均值
import torch
X = torch.arange(20, dtype = torch.float32).reshape((4, 5))
print(X)
print(X.mean())
print(X.numel())
print(X.mean() / X.numel())

print('- - - - - - - - - -')
print(X.mean(axis = 0))  # 4×5 第二个维度留下来 5列
print(X.sum(axis = 0))  # 第二个维度留下来 5列
print(X.shape)
print(X.shape[0])
print(X.shape[1])
print(X.sum(axis = 0) / X.shape[0])
print(X.sum(axis = 0) / X.shape[1])



# 矩阵某轴求和 维度不丢失
# 计算总和或均值时保持轴数不变
import torch
X = torch.arange(20, dtype = torch.float32).reshape((5, 4)) 
X_sum = X.sum(axis = 1, keepdims = True) # keepdims=True不丢掉维度，否则三维矩阵按一个维度求和就会变为二维矩阵，二维矩阵若按一个维度求和就会变为一维向量
print(X)
print(X_sum)
print(X_sum.shape) # 维度没有丢失，方便使用广播

# 矩阵广播
# 通过广播将X除以X_sum
print('------------------')
print(X / X_sum)

# 矩阵某轴累加总和
print('- - - - - - - - -')
print(X.cumsum(axis = 0))


# 向量点积
# 点积是相同位置的按元素乘积的和
import torch
x = torch.arange(4, dtype = torch.float32)
y = torch.ones(4, dtype = torch.float32)
print(x)
print(y)
print(torch.dot(x, y))

# 可以通过执行按元素乘法 然后进行求和来表示两个向量的点积
print(torch.sum(x * y))


# 矩阵向量积
# A是一个m×n的矩阵，x是一个n×1的矩阵，矩阵向量积 是一个长度为m的列向量，其第i个元素是点积
import torch
A = torch.arange(20, dtype = torch.float32).reshape((5, 4))
x = torch.arange(4, dtype = torch.float32)
print(A)
print(x)
print(A.shape)
print(x.shape)
print(torch.mv(A, x))

矩阵相乘 线性代数相乘
可以将矩阵-矩阵乘法 AB 看作是简单地执行m次矩阵-向量积 并将结果拼接在一起 形成一个n×m矩阵

import torch
A = torch.arange(20 ,dtype = torch.float32).reshape((5, 4))
B = torch.ones(4, 3)
print(A)
print(B)
print(torch.mm(A, B))

# 矩阵L2范数
# L2范数是向量元素平方和的平方根
import torch
u = torch.tensor([3.0, -4.0])
print(torch.norm(u))


# 矩阵L1范数
# L1范数 表示为向量元素的绝对值之和
print(torch.abs(u).sum())

# 矩阵F范数
# 矩阵的弗罗贝尼乌斯范数（Frobenius norm）是矩阵元素的平方和的平方根
print(torch.norm(torch.ones((4, 9)))) # 把矩阵拉成一个向量，然后再求和

注：上述内容参考b站up主“我是土堆”的视频，参考吴恩达深度学习，机器学习内容，参考李沐动手学深度学习！！！