深度学习基本原理

一、数学基础

标量和向量、矩阵、张量（tensor）

**矩阵乘法：**MxN矩阵乘 NxP矩阵得到 MxP维矩阵

numpy常用操作

.dim    #秩 轴的数量或维度的数量
.shape    #对象的尺度
.size    #对象的个数
.dtype    #对象类型
.reshape(shape)    #不改变数组元素，返回一个shape形状的数组，原数组不变
.resize(shape)    #与reshape功能一致，但改变原数组
.swapaxes(ax1,ax2)    #将数组n个维度中两个进行交换
.flatten()    #对数组进行降维，返回折叠后的一维数组，原数组不变

np.arange(n)    #类似range函数，放回ndarray类型，元素0~n-1
np.ones(shape)    #根据shape生成一个全1数组
np.zeros(shape)    #根据shape生成一个全0数组
np.full(shape,val)    #根据shape生成一个全val数组
np.eye(n)    #创建一个正方n*n的矩阵，对角线全为1其余为0
np.linspace(b,e,n)    #根据起始值等间距填充数据形成数组

二、导数

三、梯度下降算法

意义：多元函数的导数

例： 原函数

则导函数

在【1，1，1】处的梯度为【6，8，15】，梯度是一个向量

1.梯度下降法

根据梯度，更新权重

学习率控制权重更新的幅度

SGD Stochastic gradient descent

2.代码示例

选定模型结构

def func(x):
    y = w1 * x**2 + w2 * x + w3
    return y

模型参数随机初始化

w1, w2, w3 = 1, 0, -1

损失函数选用

def loss(y_pred, y_true):
    return (y_pred - y_true) ** 2

学习率设置

lr = 0.1

训练过程

for epoch in range(1000):
    epoch_loss = 0
    for x, y_true in zip(X, Y):
        # 根据当前模型参数获取预测值
        y_pred = func(x)
        # 累加当轮误差值
        epoch_loss += loss(y_pred, y_true)
        # 梯度计算
        grad_w1 = 2 * (y_pred - y_true) * x ** 2
        grad_w2 = 2 * (y_pred - y_true) * x 
        grad_w3 = 2 * (y_pred - y_true) 
        # 根据SGD公式进行权重更新
        w1 = w1 - lr * grad_w1   #sgd 
        w2 = w2 - lr * grad_w2 
        w3 = w3 - lr * grad_w3 

    epoch_loss /= len(X)
    print("第%d轮， loss %f" %(epoch, epoch_loss))
    # 训练后误差达到目标值内
    if epoch_loss < 0.0001:
        break

print(f"训练后权重:w1:{w1} w2:{w2} w3:{w3}")

3.反向传播过程

1.根据输入x和模型当前权重，计算预测值y'

2.根据y'和y使用loss函数计算loss

3.根据loss计算模型权重的梯度

4.使用梯度和学习率，根据优化器调整模型权重

权重更新方式

Gradient descent 所有样本一起计算梯度（累加）

Stochastic gradient descent 每次使用一个样本计算梯度

Mini-batch gradient descent 每次使用n个样本计算梯度（累加）

import math
import sys

# X = [0.01 * x for x in range(100)]
# Y = [2*x**2 + 3*x + 4 for x in X]


# X = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35000000000000003, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41000000000000003, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47000000000000003, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.5700000000000001, 0.58, 0.59, 0.6, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.6900000000000001, 0.7000000000000001, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79, 0.8, 0.81, 0.8200000000000001, 0.8300000000000001, 0.84, 0.85, 
# 0.86, 0.87, 0.88, 0.89, 0.9, 0.91, 0.92, 0.93, 0.9400000000000001, 0.9500000000000001, 0.96, 0.97, 0.98, 0.99]
# Y = [4.0, 4.0302, 4.0608, 4.0918, 4.1232, 4.155, 4.1872, 4.2198, 4.2528, 4.2862, 4.32, 4.3542, 4.3888, 4.4238, 4.4592, 4.495, 4.5312, 4.5678, 4.6048, 4.6422, 4.68, 4.7181999999999995, 4.7568, 4.7958, 4.8352, 4.875, 4.9152000000000005, 4.9558, 4.9968, 5.0382, 5.08, 5.122199999999999, 5.1648, 5.2078, 5.2512, 5.295, 5.3392, 5.3838, 5.4288, 5.4742, 5.5200000000000005, 5.5662, 5.6128, 5.6598, 5.7072, 5.755, 5.8032, 5.851800000000001, 5.9008, 5.9502, 6.0, 6.0502, 6.1008, 6.1518, 6.203200000000001, 6.255000000000001, 6.3072, 6.3598, 6.4128, 6.4662, 6.52, 6.5742, 6.6288, 6.6838, 6.7392, 6.795, 6.8512, 6.9078, 6.9648, 7.022200000000001, 7.08, 7.138199999999999, 7.1968, 7.2558, 7.3152, 7.375, 7.4352, 7.4958, 7.5568, 7.6182, 7.680000000000001, 7.7422, 7.8048, 7.867800000000001, 7.9312, 7.994999999999999, 8.0592, 8.1238, 8.1888, 8.2542, 8.32, 8.3862, 8.4528, 8.5198, 8.587200000000001, 8.655000000000001, 8.7232, 8.7918, 8.8608, 8.9302]    

X = [0.01 * x for x in range(100)]
Y = [2*x**2 + 3*x + 4 for x in X]

def func(x):
    y = w1 * x**2 + w2 * x + w3
    return y

def loss(y_pred, y_true):
    return (y_pred - y_true) ** 2

# 权重随机初始化
w1, w2, w3 = 1, 0, -1

# 学习率设置
lr = 0.1


# 训练过程
for epoch in range(1000):
    epoch_loss = 0
    for x, y_true in zip(X, Y):
        y_pred = func(x)
        epoch_loss += loss(y_pred, y_true)
        #梯度计算
        grad_w1 = 2 * (y_pred - y_true) * x ** 2
        grad_w2 = 2 * (y_pred - y_true) * x 
        grad_w3 = 2 * (y_pred - y_true) 
        #权重更新
        w1 = w1 - lr * grad_w1   #sgd 
        w2 = w2 - lr * grad_w2 
        w3 = w3 - lr * grad_w3 

    epoch_loss /= len(X)
    print("第%d轮， loss %f" %(epoch, epoch_loss))
    if epoch_loss < 0.0001:
        break

print(f"训练后权重:w1:{w1} w2:{w2} w3:{w3}")

#使用训练后模型输出预测值
Yp = [func(i) for i in X] 

四、pytorch

https://pytorch.org/

pytorch官方文档

五、常见网络结构

1.全连接层（线性层）

计算公式：y = w * x + b，w和b是参与训练的参数

w的维度决定了隐含层输出的维度，一般称为隐单元个数（hidden size）

举例：

输入：x （维度1 x 3） 隐含层1：w（维度3 x 5） 隐含层2: w（维度5 x 2）

代码示例：

模型定义：搭建一个2层神经网络模型

class TorchModel(nn.Module):
    def __init__(self, input_size, hidden_size1, hidden_size2):
        super(TorchModel, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size1) #w：3 * 5
        self.layer2 = nn.Linear(hidden_size1, hidden_size2) # 5 * 2

    def forward(self, x):
        x = self.layer1(x)   #shape: (batch_size, input_size) -> (batch_size, hidden_size1) 
        y_pred = self.layer2(x) #shape: (batch_size, hidden_size1) -> (batch_size, hidden_size2) 
        return y_pred

准备输入数据、建立模型

x = np.array([[3.1, 1.3, 1.2],
              [2.1, 1.3, 13]])
#建立torch模型
torch_model = TorchModel(3, 5, 2)

使用torch模型进行预测

torch_x = torch.FloatTensor(x)
y_pred = torch_model.forward(torch_x)
print("torch模型预测结果：", y_pred)

2.激活函数

为模型添加非线性因素，使模型具有拟合非线性函数的能力。无激活函数时 y = w1(w2(w3 * x + b3) +b2) + b1 仍然是线性函数

2.1.Sigmoid函数

2.2.tanh函数

2.3.Relu函数

2.4.Gelu函数

2.5.Softmax函数

3.损失函数

3.1.均方差

MSE mean square error 对均方差在做开根号，可以得到根方差

3.2.交叉熵

Cross Entropy 常用于分类任务 分类任务中，网络输出经常是所有类别上的概率分布公式：

假设一个三分类任务，某样本的正确标签是第一类，则p = 1, 0, 0, 模型预测值假设为0.5, 0.4, 0.1, 则交叉熵计算如下：