神经网络笔记

对比维度	CNN 卷积神经网络	RNN 循环神经网络
处理数据类型	空间数据（图片、矩阵）	时序序列（句子、语音、股价）
数据依赖关系	局部空间依赖，无时间先后	前后时序依赖，上下文相关
记忆能力	无记忆，各输入独立	有状态记忆，保存历史信息
运算方式	并行计算（整张图一起算）	串行逐时间步计算，速度慢
长距离依赖	靠堆叠卷积 / 全局池化间接捕捉	原生难捕捉长距离依赖（LSTM 改善）
典型优势	提取空间特征、平移不变性	理解上下文语序、时序规律
典型缺点	不懂语序、时序逻辑弱	串行慢、长序列梯度问题

总结：

CNN适合处理图片以及视频文件

RNN合适处理语言类文本、语法解析以及文档类文件

矩阵：

（数学）乘积运算法则，标记符号：A⊙B

np.dot(A,B) 要求矩阵A的行数==矩阵B的列数

1. 交换律不成立：一般 AB  ≠  BA

2. 结合律：(AB)C=A(BC)

3. 分配律：A(B+C)=AB+AC

4. 单位矩阵：AE=EA=A

单位矩阵示例、（注意是正对角线，反对角线不是）：

E=\begin{pmatrix} 1 , 0 , 0 , 0 \\ 0 , 1 , 0 , 0 \\ 0 , 0 , 1 , 0 \\ 0 , 0 , 0 , 1 \\ \end{pmatrix}

运算示例：

A=\begin{pmatrix} 1 , 2 \\ 3 , 4 \end{pmatrix},\quad B=\begin{pmatrix} 5 , 6 \\ 7 , 8 \end{pmatrix}

A：2行2列，B：2行2列，乘积 C=AB 为2×2 1. 算 c_{11}（A第1行 · B第1列） c_{11}=1*5 + 2*7 = 19 2. 算 c_{12}（A第1行 · B第2列） c_{12}=1*6 + 2*8 = 22 3. 算 c_{21}（A第2行 · B第1列） c_{21}=3*5 + 4*7 = 43 4. 算 c_{22}（A第2行 · B第2列） c_{22}=3*6 + 4*8 = 50

最终结果：

AB=\begin{pmatrix} 19 , 22 \\ 43 , 50 \end{pmatrix}

普通矩阵相乘，标记符号：A×B

A*B  逐元素乘法（哈达玛积 Hadamard product），对应位置元素相乘，两个矩阵形状要求一致

运算示例：

A=\begin{pmatrix} a11 , a12 \\ a21 , a22 \end{pmatrix},\quad B=\begin{pmatrix} b11 , b12 \\ b21 , b22 \end{pmatrix}

最终结果：

A*B=\begin{pmatrix} a11*b11 , a12*b12 \\ a21*b21 , a22*b22 \end{pmatrix}

激活函数：

个人理解就是矩阵的值范围化处理（专业叫啥？想叫归一化的，简单函数适用，但复杂函数并不适用，因为精度并没有减少）

一、sigmoid函数

def sigmoid(x):
    return 1 / ( 1 + np.exp(-x) )

二、silu函数

def silu(x):
    return x * sigmoid(x)

二、阶跃函数

def step_function(x):
    return np.array(x > 0, dtype=np.int)

三、ReLu函数

def relu(x):
    return np.maximum(0, x)

四、softmax函数

函数作用：将所有元素调整为0-1之间的小数，并且各元素相加总和为1，作用于概率统计计算

def softmax(a):
    # 不会改变函数外a里面元素的值
    a = a - np.max(a) 
    exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    # 这时y里面所有元素和为:1
    return y

五、tanh函数

np.tanh(x)

误差计算函数

注意：所计算后的误差值不参与梯度反向传播计算中

# 这里的t是正确的标签列表值
def cross_entropy_error(y, t):
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)
        
    
    t = t.argmax(axis=1)
        
  
    batch_size = y.shape[0]

    return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size

机器学习与神经网络的不同

池化：

个人理解就是多层矩阵降维（扁平化）

池化一般也就两种： AvgPool2d 平均池化、MaxPool2d 最大池化（听字面意思就能知道咋算的了）

卷积层：

个人理解就是多层矩阵运算

参数值说明：P（填充值，左边周围一堆0的那个）FH（卷积核高，黄色那个）FW（卷积核宽，黄色那个）S（计算步长）

以下面

nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2)

创建一个2D 卷积层，各参数含义：

    in_channels=1：输入通道数为 1

    代表输入是单通道图像（灰度图）

    out_channels=6：输出通道数为 6

    表示该层包含6 个卷积核，最终输出 6 张特征图。（实际上就是4×6通道，图片上是4×1通道）

    kernel_size=5：卷积核大小为 5×5（对应黄色那个）。

    padding=2：四周填充 2 个像素（左边的一圈0填充两层）

numpy数组运算说明：

• 基本操作

以二维矩阵数组U作为示例：

U[:1] 取第一行数据（0.34095,-0.0000,-0.0000,0.12052...）

U[:,0] 取第一列数据 （0.34095,-0.0000,0.43631,0.0000...） U[:,1] 取第二列数据 （-0.0000,-0.59764,-0.0000,0.49783...）

• 高级索引​操作

x=np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

print(x[[0,2,1],[2,0,3]])

相当于取值 x[0,2],x[2,0],x[1,3] 元素组成一个新数组，即 [3,11 ,9]

• [...]运算符

作用：将数组内元素进行实际替换而非引用替换

代码示例：

import numpy as np


def init_handler():
    A = np.array([[1,3,5,7,9,2,4,6,8,0]])
    G = [np.zeros_like(A)]
    return A,G

# 初始化
A,G=init_handler()

# 情况一，不用[...]操作符的情况下
G[0]=A
print(G)
A[0]=[-1,3,-5,7,-9,2,-4,6,-8,0]
print(G)

# 初始化
A,G=init_handler()

# 情况二，用[...]操作符的情况下
G[0][...]=A
print(G)
A[0]=[-1,3,-5,7,-9,2,-4,6,-8,0]
print(G)

结果：

[array([[1, 3, 5, 7, 9, 2, 4, 6, 8, 0]])]
[array([[-1,  3, -5,  7, -9,  2, -4,  6, -8,  0]])]
[array([[1, 3, 5, 7, 9, 2, 4, 6, 8, 0]])]
[array([[1, 3, 5, 7, 9, 2, 4, 6, 8, 0]])]

• T运算符作用

作用：进行数组转置（三行五列变成五行三列）

import numpy as np


x=np.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

print(x)
print(x.shape)
print(x.T)
print(x.T.shape)

结果：

[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]]
(3, 5)
[[ 1  6 11]
 [ 2  7 12]
 [ 3  8 13]
 [ 4  9 14]
 [ 5 10 15]]
(5, 3)

• argmax运算

作用：每行取最大值索引

import numpy as np

t = np.array([[0, 1, 0, 0],   # 类别1
              [0, 0, 1, 0],   # 类别2
              [1, 0, 0, 0]])  # 类别0

# argmax(axis=1) → 每行取最大值索引
t=t.argmax(axis=1)
print(t)
t = np.array([[0, 1, 2, 0],   # 类别1
              [0, 2, 1, 0],   # 类别2
              [1, 0, 0, 2]])  # 类别0

t=t.argmax(axis=1)
print(t)

结果：

[1 2 0]
[2 1 3]