人工神经网络

阅读数: 10000次 2022-02-07

学习及作业

简单介绍

…….

符号表示

Wab	代表结点a到结点b的权重
ya	代表结点a的输出值
Za	代表结点a的输入值
C	最终的损失函数

损失函数
$$
C=\frac{1}{2}errors^2
$$
其中errors是真实值与预测值的差值，目的是为了减少损失，从而调节参数，减少损失。

例子

数据用矩阵表示就是下面这样的
$$
输入数据：
Z_a=\begin{bmatrix}
0.35\
0.9\
\end{bmatrix}
$$

$$
权重：
w_0=\begin{bmatrix}
0.1&0.8\
0.4&0.6\
\end{bmatrix}\
\
权重:
w_1=\begin{bmatrix}
0.3&0.9\
\end{bmatrix}
$$

自然语言描述算法

1.初始化，用小的随机数给各权值和阈值赋初值。

2.读取网络参数和训练样本集。

3.数据处理，可以进行归一化（数据映射到0~1，方便统一处理）。

4.对训练集中每个样本进行计算。

①前向计算隐层、输出层各神经元的输出。

②计算期望输出与网络输出的误差。

③反向计算修正网络权值和阈值。

5.若满足精度要求或其他退出条件，则结束训练，否则转步骤4继续。

6.结果分析与输出。

代码

import numpy as np
def nonlin(x, deriv=False):
	if deriv == True:
	    return x * (1 - x) #如果deriv为true，求导数
	return 1 / (1 + np.exp(-x))
X = np.array([[0.35],[0.9]]) #输入层y = np.array([[0.5]]) #输出值
y=np.array([[0.5]]) #定义的输出的值

W0 = np.array([[0.1,0.8],[0.4,0.6]])
W1 = np.array([[0.3,0.9]])
print("初始权值: ")
print(W0)
print(W1)

for i in range(1,10):
	l0 = X #相当于文章中x0
	l1 = np.dot(W0,l0)             #输入值与权值相乘，即矩阵相乘
	l2 = np.dot(W1,l1)
	#print(l1,l2)                  #乘积结果
	l2_error = y - l2              #真实值与预测值的差值
	#print(l2_error)
	Error = 1/2.0*(y-l2)**2        #损失函数
	l2_delta = l2_error * nonlin(l2, deriv=True) #this will backpack
	l1_error = l2_delta*W1        #反向传播
	l1_delta = l1_error * nonlin(l1, deriv=True)
	W1 += l2_delta*l1.T #修改权值
	W0 += l0.T.dot(l1_delta)
	print("第",i,"次修改后的权值: ")
	print(W0)
	print(W1)

作业

numpy的使用补充

numpy函数

函数格式	用途
np.array()	定义数组
x.shape[0]	得到矩阵的行数
x.shape[1]	得到矩阵的列数
x.reshape(N,-1)	固定行数，-1表示行数需要计算
np.dot(m,n)	m和n两个矩阵的叉乘
np.sum()	求和函数
axis=0	返回按列相加的一个数组
keepdims	保持原有维度输出
np.random.randn(m,n)	随机生成一个维度位m*n的矩阵(元素大小在(0,1)之间)
np.zeros(m,n)	生成一个m*n的元素全为0的矩阵
np.maximum(0,H)	只返回(0，H)中大的元素
np.exp(x)	计算e的x次幂
np.arange(N)	生成数组
np.copy()	函数起名，copy
np.log(x)	计算以e位底的x的log值

softmax层函数

类似于归一化处理，目的是为了使输出的结果更为直观。那么我们能不能使得一系类预测值y变为相应的概率，概率大的就为输出的最终结果呢？当然可以。

简单来说分三步进行：

（1）以e为底对所有元素求指数幂；

（2）将所有指数幂求和；

（3）分别将这些指数幂与该和做商。

这样求出的结果中，一系列的和一定为1，而每个元素可以代表概率值。

代码：

import numpy as np
def affine_forward(x, w, b):   #w为传进的权值
    out = None                       # 初始化返回值为None
    N =x.shape[0]                    # 重置输入参数X的形状（重置矩阵的行数）
    x_row = x.reshape(N, -1)         # (N,D)
    out = np.dot(x_row, w) + b       # (N,M) 矩阵相乘
    cache = (x, w, b)                # 缓存值，反向传播时使用
    return out,cache
def affine_backward(dout, cache):
    x, w, b = cache                              # 读取缓存
    dx, dw, db = None, None, None                # 返回值初始化
    dx = np.dot(dout, w.T)                       # (N,D)
    dx = np.reshape(dx, x.shape)                 # (N,d1,...,d_k)
    x_row = x.reshape(x.shape[0], -1)            # (N,D)
    dw = np.dot(x_row.T, dout)                   # (D,M)
    db = np.sum(dout, axis=0, keepdims=True)     # (1,M)
    return dx, dw, db
X = np.array([[2,1],
            [-1,1],
            [-1,-1],
            [1,-1]])      # 用于训练的坐标，对应的是I、II、III、IV象限
t = np.array([0,1,2,3])   # 标签，对应的是I、II、III、IV象限
np.random.seed(1)         # 有这行语句，你们生成的随机数就和我一样了
# 一些初始化参数
input_dim = X.shape[1]     # 输入参数的维度，此处为2，即每个坐标用两个数表示 得到矩阵的列数
num_classes = t.shape[0]   # 输出参数的维度，此处为4，即最终分为四个象限     得到矩阵的行数
hidden_dim = 50            # 隐藏层维度，为可调参数
reg = 0.001                # 正则化强度，为可调参数
epsilon = 0.001            # 梯度下降的学习率，为可调参数
# 初始化W1，W2，b1，b2
W1 = np.random.randn(input_dim, hidden_dim)     # (2,50)
W2 = np.random.randn(hidden_dim, num_classes)   # (50,4)
b1 = np.zeros((1, hidden_dim))                  # (1,50)
b2 = np.zeros((1, num_classes))                 # (1,4)
for j in range(10000):   #这里设置了训练的循环次数为10000
 # ①前向传播
    H,fc_cache = affine_forward(X,W1,b1)                 # 第一层前向传播
    H = np.maximum(0, H)                                 # 激活 H为最大值
    relu_cache = H                                       # 缓存第一层激活后的结果
    Y,cachey = affine_forward(H,W2,b2)                   # 第二层前向传播
 # ②Softmax层计算
    probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
    probs /= np.sum(probs, axis=1, keepdims=True)        # Softmax算法实现
 # ③计算loss值
    N = Y.shape[0]                                       # 值为4 行数
    print(probs[np.arange(N), t])                        # 打印各个数据的正确解标签对应的神经网络的输出
    loss = -np.sum(np.log(probs[np.arange(N), t])) / N   # 计算loss
    print(loss)                                          # 打印loss
 # ④反向传播
    dx = probs.copy()                                    # 以Softmax输出结果作为反向输出的起点
    dx[np.arange(N), t] -= 1
    dx /= N                                              # 到这里是反向传播到softmax前
    dh1, dW2, db2 = affine_backward(dx, cachey)          # 反向传播至第二层前
    dh1[relu_cache <= 0] = 0                             # 反向传播至激活层前
    dX, dW1, db1 = affine_backward(dh1, fc_cache)        # 反向传播至第一层前
# ⑤参数更新
    dW2 += reg * W2
    dW1 += reg * W1
    W2 += -epsilon * dW2
    b2 += -epsilon * db2
    W1 += -epsilon * dW1
    b1 += -epsilon * db1
test = np.array([[2,2],[-2,2],[-2,-2],[2,-2]])
H,fc_cache = affine_forward(test,W1,b1)               #仿射
H = np.maximum(0, H)                                  #激活
relu_cache = H
Y,cachey = affine_forward(H,W2,b2)  #仿射
 # Softmax
probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
probs /= np.sum(probs, axis=1, keepdims=True)  # Softmax
print(probs)
for k in range(4):
    print(test[k,:],"所在的象限为",np.argmax(probs[k,:])+1)