ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

神经网络示例代码

2021-07-31 21:04:00  阅读:170  来源: 互联网

标签:20 示例 代码 cache 形状 shape 神经网络 dx np


  1 import numpy as np
  2 
  3 '''
  4 前向传播函数:
  5 -x :包含输入数据的numpy数组,形状为(N,d_1,...,d_k)
  6 -w :形状为(D,M)的一系列权重
  7 -b :偏置,形状为(M,) 
  8 
  9 关于参数的解释:
 10 在我们这个例子中输入的数据为
 11 [[2,1],  
 12 [-1,1],  
 13 [-1,-1],  
 14 [1,-1]]
 15 
 16 它是一个4行2列的二维数组,那么x的形状就是(4,2),
 17 对应的参数N=4,d_1=2。这是我们用来做训练的坐标数据,
 18 分别对应了I、II、III、IV象限。
 19 在某些应用场景中,x的维度可能更高。比如对于一个20*20像素的4张灰度图,x的形状将是(4,20,20),对应的参数就是N=4,d_1=20,d_2=20。(这里边第一个参数用N表示,它代表的是同时用于计算前向传播的数据有几组,后边的参数d_1~d_k代表的是数据本身的形状。)
 20 
 21 对于这种维度大于2的x来说,需要对其进行重新塑形,也就是将(4,20,20)的高维数组变化为(4,20*20)这样的二位数组。
 22 
 23 为什么要这么做呢?是为了方便计算。这样变换之后高维的向量被“拍扁”成一维向量(长度为20*20的一维向量),对应的W和b也都是一维的,既统一了参数形式,又不会影响数据的正常使用。
 24 
 25 这个“拍扁”的动作,是用上述代码中的这两行完成的:
 26 
 27 N = x.shape[0]                 # 重置输入参数X的形状     
 28 x_row = x.reshape(N,-1)        # (N,D)
 29 x.shape[0]是获取数组x的第0维长度,也就是数据的组数,对于上述的4行2列的数组,其值为4;对于上述(4,20,20)的数组,其值也为4.
 30 
 31 x.reshape(N,-1)是对x重新塑形,即保留第0维,其他维度排列成1维。对于形状为(4,2)的数组,其形状不变,对于形状为(4,20,20)的数组,形状变为(4,20*20)。以此类推。
 32 
 33 在完成reshape后,就可以进行矩阵的线性运算了:
 34 
 35 out = np.dot(x_row, w)+ b       # (N,M)
 36 .dot就是numpy中的函数,可以实现x_row与w的矩阵相乘。x_row的形状为(N,D),w的形状为(D,M),得到的out的形状是(N,M)。
 37 
 38 cache =(x, w, b)   # 缓存值,反向传播时使用
 39 上面这句是将当前x,w和b的值缓存下来,留作反向传播时使用。
 40 '''
 41 
 42 
 43 def affine_forward(x, w, b):
 44     result = None
 45     N = x.shape[0]
 46     x_row = x.reshape(N, -1)
 47     result = np.dot(x_row, w) + b  # dot是np中的函数。用来做矩阵乘法
 48     cache = (x, w, b)
 49     return result, cache
 50 
 51 
 52 # 反向传播函数
 53 # - x:包含输入数据的numpy数组,形状为(N,d_1,...,d_k)
 54 # - w:形状(D,M)的一系列权重
 55 # - b:偏置,形状为(M,)
 56 def affine_backward(dout, cache):
 57     x, w, b = cache  # 读取缓存
 58     dx, dw, db = None, None, None  # 返回值初始化
 59     dx = np.dot(dout, w.T)  # (N,D)
 60     dx = np.reshape(dx, x.shape)  # (N,d1,...,d_k)
 61     x_row = x.reshape(x.shape[0], -1)  # (N,D)
 62     dw = np.dot(x_row.T, dout)  # (D,M)
 63     db = np.sum(dout, axis=0, keepdims=True)  # (1,M)
 64     return dx, dw, db
 65 
 66 
 67 X = np.array([[2, 1],
 68               [-1, 1],
 69               [-1, -1],
 70               [1, -1]])  # 用于训练的坐标,对应的是I、II、III、IV象限
 71 t = np.array([0, 1, 2, 3])  # 标签,对应的是I、II、III、IV象限
 72 np.random.seed(1)  # 有这行语句,你们生成的随机数就和我一样了
 73 
 74 # 一些初始化参数
 75 input_dim = X.shape[1]  # 输入参数的维度,此处为2,即每个坐标用两个数表示
 76 num_classes = t.shape[0]  # 输出参数的维度,此处为4,即最终分为四个象限
 77 hidden_dim = 50  # 隐藏层维度,为可调参数
 78 reg = 0.001  # 正则化强度,为可调参数
 79 epsilon = 0.001  # 梯度下降的学习率,为可调参数
 80 # 初始化W1,W2,b1,b2
 81 W1 = np.random.randn(input_dim, hidden_dim)  # (2,50)
 82 W2 = np.random.randn(hidden_dim, num_classes)  # (50,4)
 83 b1 = np.zeros((1, hidden_dim))  # (1,50)
 84 b2 = np.zeros((1, num_classes))  # (1,4)
 85 
 86 for j in range(10000):  # 这里设置了训练的循环次数为10000
 87     # ①前向传播
 88     H, fc_cache = affine_forward(X, W1, b1)  # 第一层前向传播
 89     H = np.maximum(0, H)  # 激活
 90     relu_cache = H  # 缓存第一层激活后的结果
 91     Y, cachey = affine_forward(H, W2, b2)  # 第二层前向传播
 92     # ②Softmax层计算
 93     probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
 94     probs /= np.sum(probs, axis=1, keepdims=True)  # Softmax算法实现
 95     # ③计算loss值
 96     N = Y.shape[0]  # 值为4
 97     print(probs[np.arange(N), t])  # 打印各个数据的正确解标签对应的神经网络的输出
 98     loss = -np.sum(np.log(probs[np.arange(N), t])) / N  # 计算loss
 99     print(loss)  # 打印loss
100     # ④反向传播
101     dx = probs.copy()  # 以Softmax输出结果作为反向输出的起点
102     dx[np.arange(N), t] -= 1  #
103     dx /= N  # 到这里是反向传播到softmax前
104     dh1, dW2, db2 = affine_backward(dx, cachey)  # 反向传播至第二层前
105     dh1[relu_cache <= 0] = 0  # 反向传播至激活层前
106     dX, dW1, db1 = affine_backward(dh1, fc_cache)  # 反向传播至第一层前
107     # ⑤参数更新
108     dW2 += reg * W2
109     dW1 += reg * W1
110     W2 += -epsilon * dW2
111     b2 += -epsilon * db2
112     W1 += -epsilon * dW1
113     b1 += -epsilon * db1
114 
115 
116 test = np.array([[2,-3],[-2,2],[-2,-2],[2,-2]])
117 H,fc_cache = affine_forward(test,W1,b1)               #仿射
118 H = np.maximum(0, H)                                  #激活
119 relu_cache = H
120 Y,cachey = affine_forward(H,W2,b2)  #仿射
121  # Softmax
122 probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
123 probs /= np.sum(probs, axis=1, keepdims=True)  # Softmax
124 print(probs)
125 for k in range(4):

 

标签:20,示例,代码,cache,形状,shape,神经网络,dx,np
来源: https://www.cnblogs.com/sxdxanke/p/15085214.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有