斯坦福大学深度学习公开课cs231n学习笔记（9）softmax分类和神经网络分类代码实现

最新推荐文章于 2023-10-09 22:27:49 发布
最新推荐文章于 2023-10-09 22:27:49 发布
阅读量3.1k 收藏 20
点赞数 2
分类专栏： 深度学习(deep learning) 文章标签： 深度学习公开课

在前面的几节课中，讲述了神经网络的基本原理和参数的优化方法等，在这节课中，讲师前面的知识进行总结运用，通过构建Softmax分类器和一个小型的神经网络让我们有更加深入和直接的了解。我按照课中的步骤进行实现。

第一步：生成数据

N = 100 # number of points per class
D = 2 # dimensionality
K = 3 # number of classes
import numpy as np
import matplotlib.pyplot as plt
X = np.zeros((N*K,D)) # data matrix (each row = single example)
y = np.zeros(N*K, dtype='uint8') # class labels
for j in range(K):
  ix = range(N*j,N*(j+1))
#  print("ix:",ix)
  r = np.linspace(0.0,1,N) # radius
  t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta
  X[ix] = np.c_[r*np.sin(t), r*np.cos(t)] #np.c_转换为多列数据
#  print("X[ix]:",X[ix])
  y[ix] = j #给300个点分类，每一百为一类，即[0，99]为0类，[100，199]为1类，[200,299]为2类
# lets visualize the data:
plt.scatter(X[:, 0], X[:, 1], c=y, s=50)#scatter画散点图；
#plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.show()
程序解释：
程序中，X是大小为（300,2）矩阵数据，第一列数据为r*sin(t)，第二列数据为r*cos(t);其中，r是[0:0.01:1]的100个半径序列，t为和r相同大小的角度序列。
plt.scatter功能为显示散列数据。

第二步：训练softmax分类器

2.1初始化参数W和b

# initialize parameters randomly
W = 0.01 * np.random.randn(D,K)
b = np.zeros((1,K))
设置W为（2,3）权重矩阵，b为（1,3）偏置矩阵。

2.2求不同分类的分值

# compute class scores for a linear classifier
scores = np.dot(X, W) + b
在这个例子中有300个二维点数据，np.dot乘积运算，数组的分数将有大小[ 300×3 ]，即给出3个分类对应的分数。

2.3计算损失函数

由之前的课中我们知道softmax的损失函数计算公式为：

其中，log 内部式子的范围是[0,1]，当分类错误时，此值接近0，Li 将是正无穷；当分类正确时，此值接近1，Li 将接近0。
上述过程的实现为： 
num_examples = X.shape[0]
# get unnormalized probabilities
exp_scores = np.exp(scores)
# normalize them for each example
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) #每个点分类的得分所占概率（包括正确分类和错误分类）,300*3
corect_logprobs = -np.log(probs[range(num_examples),y]) #probs[range(num_examples),y]是正确分类的概率
probs为[300,3]矩阵，元素对应不同分类的概率值。corect_logprobs对应Li 值，程序中y为数据生成时的标记，值为[100*0,100*1,100*2]，即对应分类类别0,1,2。
整个softmax分类器的损失被定义为包含训练实例和正则化两部分的平均交叉熵损失：
上面公式的实现为： 
# compute the loss: average cross-entropy loss and regularization
data_loss = np.sum(corect_logprobs)/num_examples
reg_loss = 0.5*reg*np.sum(W*W)
loss = data_loss + reg_loss
其中，公式中的λ存放在reg中。

2.4反向传播计算梯度

有了上面计算损失函数的方法，现在需要使用梯度下降减小损失函数值，即从随机参数开始，评估损失函数相对于参数的梯度，以便知道如何改变参数以减少损失。引入中间变量p，它是（正规化）概率的一个向量：

在softmax学习笔记中，我们知道对Li求导结果为：

假设计算出一组概率： p=[0.2,0.3,0.5]; 而正确的分类是中间那一类，所以用上面的求导公式可以求得：df = [0.2, -0.7, 0.5]；
上述公式实现为： 
dscores = probs
dscores[range(num_examples),y] -= 1
dscores /= num_examples
计算分值公式为： scores = np.dot(X, W) + b，现在求出了 dscores，通过对两边分别求导，可以反推出： dW 和 db 
dW = np.dot(X.T, dscores)
db = np.sum(dscores, axis=0, keepdims=True)
dW += reg*W # don't forget the regularization gradient
其中，对W求导时，两边同乘 X.T。第三行dW加上了正则项（1/2*λ*W^2）部分对W的导数（λW），

2.5 参数更新

W += -step_size * dW
b += -step_size * db
综上，我们便完成了整个softmax分类函数的训练过程，整个过程实现代码如下： 
N = 100 # number of points per class
D = 2 # dimensionality
K = 3 # number of classes
import numpy as np
import matplotlib.pyplot as plt
X = np.zeros((N*K,D)) # data matrix (each row = single example)
y = np.zeros(N*K, dtype='uint8') # class labels
for j in range(K):
  ix = range(N*j,N*(j+1))
#  print("ix:",ix)
  r = np.linspace(0.0,1,N) # radius
  t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta
  X[ix] = np.c_[r*np.sin(t), r*np.cos(t)] #np.c_转换为多列数据
#  print("X[ix]:",X[ix])
  y[ix] = j
# lets visualize the data:
plt.scatter(X[:, 0], X[:, 1], c=y, s=50)
#plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.show()

#Train a Linear Classifier

# initialize parameters randomly
W = 0.01 * np.random.randn(D,K)
b = np.zeros((1,K))

# some hyperparameters
step_size = 1e-0
reg = 1e-3 # regularization strength

# gradient descent loop
num_examples = X.shape[0]
for i in range(200):
  
  # evaluate class scores, [N x K]
  scores = np.dot(X, W) + b 
  
  # compute the class probabilities
  exp_scores = np.exp(scores)
  tmp= np.sum(exp_scores, axis=1, keepdims=True) 
  probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # [N x K]
  
  # compute the loss: average cross-entropy loss and regularization
  corect_logprobs = -np.log(probs[range(num_examples),y])
  data_loss = np.sum(corect_logprobs)/num_examples
  reg_loss = 0.5*reg*np.sum(W*W)
  loss = data_loss + reg_loss
  if i % 10 == 0:
    print ("iteration %d: loss %f" % (i, loss))
  
  # compute the gradient on scores
  dscores = probs
  dscores[range(num_examples),y] -= 1
  dscores /= num_examples
  
  # backpropate the gradient to the parameters (W,b)
  dW = np.dot(X.T, dscores)
  db = np.sum(dscores, axis=0, keepdims=True)
  
  dW += reg*W # regularization gradient
  
  # perform a parameter update
  W += -step_size * dW
  b += -step_size * db
经过若干次迭代后（函数中设置最大迭代次数为200），得到参数W和b。之后我们可以看下训练后的神经网络的准确性，即看一下我们假设第二类是正确分类所占的比重是多少。 
# evaluate training set accuracy
scores = np.dot(X, W) + b
predicted_class = np.argmax(scores, axis=1)
print ('training accuracy: %.2f' % (np.mean(predicted_class == y)))
上述过程的运行结果为： 
iteration 0: loss 1.098034
iteration 10: loss 0.905211
iteration 20: loss 0.833959
iteration 30: loss 0.801773
iteration 40: loss 0.785123
iteration 50: loss 0.775711
iteration 60: loss 0.770056
iteration 70: loss 0.766508
iteration 80: loss 0.764208
iteration 90: loss 0.762681
iteration 100: loss 0.761647
iteration 110: loss 0.760935
iteration 120: loss 0.760440
iteration 130: loss 0.760092
iteration 140: loss 0.759845
iteration 150: loss 0.759669
iteration 160: loss 0.759543
iteration 170: loss 0.759451
iteration 180: loss 0.759385
iteration 190: loss 0.759337
training accuracy: 0.53

程序得到的分类准确性为53%，由于生成的数据本身不是线性的，所以使用线性分类器得到这个结果也是情理之中的事，使用下面的代码可以将分类边界绘制出来：

# plot the resulting classifier
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))
Z = np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
fig = plt.figure()
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()

训练神经网络：

上面用线性分类器分类的结果为53%，可见效果一般，所以下面使用神经网络进行测试，对比下线性分类器的效果如何？ 
#generate data
N = 100 # number of points per class
D = 2 # dimensionality
K = 3 # number of classes
import numpy as np
import matplotlib.pyplot as plt
X = np.zeros((N*K,D)) # data matrix (each row = single example)
y = np.zeros(N*K, dtype='uint8') # class labels
for j in range(K):
  ix = range(N*j,N*(j+1))
#  print("ix:",ix)
  r = np.linspace(0.0,1,N) # radius
  t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta
  X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
#  print("X[ix]:",X[ix])
  y[ix] = j
# lets visualize the data:
plt.scatter(X[:, 0], X[:, 1], c=y, s=50)
#plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.show()

# initialize parameters randomly
h = 100 # size of hidden layer
W = 0.01 * np.random.randn(D,h)
b = np.zeros((1,h))
W2 = 0.01 * np.random.randn(h,K)
b2 = np.zeros((1,K))

# some hyperparameters
step_size = 1e-0
reg = 1e-3 # regularization strength

# gradient descent loop
num_examples = X.shape[0]
for i in range(10000):
  
  # evaluate class scores, [N x K]
  hidden_layer = np.maximum(0, np.dot(X, W) + b) # note, ReLU activation
  scores = np.dot(hidden_layer, W2) + b2
  
  # compute the class probabilities
  exp_scores = np.exp(scores)
  probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # [N x K]
  
  # compute the loss: average cross-entropy loss and regularization
  corect_logprobs = -np.log(probs[range(num_examples),y])
  data_loss = np.sum(corect_logprobs)/num_examples
  reg_loss = 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2)
  loss = data_loss + reg_loss
  if i % 1000 == 0:
    print ("iteration %d: loss %f" % (i, loss))
  
  # compute the gradient on scores
  dscores = probs
  dscores[range(num_examples),y] -= 1
  dscores /= num_examples
  
  # backpropate the gradient to the parameters
  # first backprop into parameters W2 and b2
  dW2 = np.dot(hidden_layer.T, dscores)
  db2 = np.sum(dscores, axis=0, keepdims=True)
  # next backprop into hidden layer
  dhidden = np.dot(dscores, W2.T)
  # backprop the ReLU non-linearity
  dhidden[hidden_layer <= 0] = 0
  # finally into W,b
  dW = np.dot(X.T, dhidden)
  db = np.sum(dhidden, axis=0, keepdims=True)
  
  # add regularization gradient contribution
  dW2 += reg * W2
  dW += reg * W
  
  # perform a parameter update
  W += -step_size * dW
  b += -step_size * db
  W2 += -step_size * dW2
  b2 += -step_size * db2
  
# evaluate training set accuracy
hidden_layer = np.maximum(0, np.dot(X, W) + b)
scores = np.dot(hidden_layer, W2) + b2
predicted_class = np.argmax(scores, axis=1)
print ('training accuracy: %.2f' % (np.mean(predicted_class == y)))

# plot the resulting classifier
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))
Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b), W2) + b2
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
fig = plt.figure()
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.show()
程序解释：
上面代码构建的是一个两层神经网络，第一层隐层有100个神经元，输出层有3种分类，激活函数使用的是ReLU非线性函数：


对r求导，得：

当求导梯度小于0时，将梯度值设为零，即程序中的语句：dhidden[hidden_layer <= 0] = 0
其他步骤类似于softmax分类器，此函数的运行结果为： 
iteration 0: loss 1.098593
iteration 1000: loss 0.313864
iteration 2000: loss 0.261329
iteration 3000: loss 0.254359
iteration 4000: loss 0.250366
iteration 5000: loss 0.248206
iteration 6000: loss 0.247869
iteration 7000: loss 0.247758
iteration 8000: loss 0.247667
iteration 9000: loss 0.247605
training accuracy: 0.99
准确性为99%，比第一种softmax线性分类器准确性提高了很多，其决策边界图为：


参考：

http://cs231n.github.io/neural-networks-case-study/

http://www.yiibai.com/numpy/

http://matplotlib.org/index.html

Naruto_Q
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
基于python实现两层神经网络分类器用于手写数字识别源码+使用说明(深度学习课程作业).zip
07-24
基于python实现两层神经网络分类器用于手写数字识别源码+使用说明(深度学习课程作业).zip 该项目是个人课程作业项目，答辩评审分达到95分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。...
softmax函数实现（C语言）
思想的苇草
01-09 2486
关于softmax函数：https://www.cnblogs.com/alexanderkun/p/8098781.html C语言实现： #include "stdio.h" #include "math.h" void main(void) { int i = 0; double sum = 0; int vertor0[6] = {1,2,3,4,5,6}; //初始向...
sigmoid和softmax函数的C++实现
热门推荐
liuyanfeier的专栏
03-17 1万+
float sigmoid(float x) { return (1 / (1 + exp(-x))); }float sigmoid_dy_dz(float x) { return (x * (1.0 - x)); }float tanh_dy_dz(float x) { return (1.0 - x*x); } //对每一行进行softmax void softmax(
无框架 使用c++从零开始实现 卷积 全连接 softmax 入门深度学习 CPU版 梯度下降
kekezhu0000的专栏
12-16 739
无框架 使用c++从0开始实现 卷积 全连接 softmax 入门深度学习 经过一段时间的努力，终于用C++把卷积写完成了。因为深度学习太火了，所以 忍不住就试试。先是找资料看看需要什么，然后进行学习，恶补线性代数、微积分、概率论，感觉能用到的知识点学差不多了就开始代码。现在成熟框架太多了，为了更好的理解选择了自己造轮子，能力有限，所以这个过程很漫长也很痛苦！ 太多的技术细节网上都有资料，我也不用多说，因为没有大神讲的透彻，理论是一回事，实际做又是另一回事。理论上的事儿我只说两点，第一个是多层卷积卷积
动手学深度学习c0304softmax函数
Ysdabaicai的博客
06-08 288
学习ing http://zh.d2l.ai/
深度学习入门初探——C语言版的softmax实现
chenleiyfk的博客
12-04 916
在机器学习的问题上可以大致地分为分类问题和回归问题。回归问题简言之就是根据某个输入来预测或计算出一个数值的结果，基本上使用的就是恒等函数；而分类问题是数据属于哪一个类别的问题，二分类和多分类等，使用的是softmax函数。 其Python版的代码在这里：输出层的介绍 深度学习入门初探——多层感知机的神经网络式实现https://www.toutiao.com/i7027833090944860710/?group_id=7027833090944860710 ...
机器学习 | 使用TensorFlow搭建神经网络实现鸢尾花分类
12-21
鸢尾花分类问题是机器学习领域一个非常经典的问题，本文将利用神经网络来实现鸢尾花分类 实验环境：Windows10、TensorFlow2.0、Spyder 参考资料：人工智能实践：TensorFlow笔记第一讲 1、鸢尾花分类问题描述 根据...
改进Softmax分类器的深度卷积神经网络及其在人脸识别中的应用.pdf
09-26
改进Softmax分类器的深度卷积神经网络及其在人脸识别中的应用 本文提出了一种有效的特征学习方法，通过构建9层结构的卷积神经网络，使用Softmax回归算法进行人脸分类识别。卷积神经网络在输出层使用改进的Softmax...
基于卷积深度神经网络的句子单子关系分类
01-17
本文利用卷积深度神经网络（DNN）提取词法和句子级别的功能。我们的方法将所有单词标记作为输入没有复杂的预处理。首先，单词标记被转换为向量查找单词嵌入。然后，根据给定的词汇级别特征提取名词。同时，使用卷积...
CS231n深度学习课程作业1实现
11-20
CS231n深度学习课程作业1实现，实现完整的KNN、SVM、softmax、二层神经网络的作业。
简单的神经网络实现softmax分类
07-27
实现三类螺旋分布的三类点的区分，分布采用线性分类的方法和softmax分类器分类器的使用，简单神经网络的流程。python3.6
softmax回归代码
01-22
用python编写的softmax回归代码，可实现多分类功能，需安装numpy和tensorflow库，tensorflow主要用到mnist手写数字的数据集，如果自备了数据的话可以不安装tensorflow。
softmax回归与经典BP神经网络
07-29
本ppt讲解了softmax回归的推导由来来龙去脉和BP算法的推导，以及softmax回归在深度学习中的应用
Matlab实现softmax分类
07-15
用matlab实现softmax回归
斯坦福机器学习ML公开课笔记1-15（完整版、带目录索引和NG原版讲义）
11-07
1-15节全部完整版讲义！超清分享~~~（附赠目录索引和NG原版讲义） 含金量高，独家整理~~ 目录如下： 公开课笔记1-2——线性规划、梯度下降、正规方程组 公开课笔记3——局部加权回归、逻辑斯蒂回归、感知器算法 公开课笔记4——牛顿方法、指数分布族、广义线性模型 公开课笔记5——生成学习、高斯判别、朴素贝叶斯 公开课笔记6——NB多项式模型、神经网络、SVM初步 公开课笔记7——最优间隔分类、原始/对偶问题、SVM对偶 公开课笔记8———核技法、软间隔分类器、SMO算法 公开课笔记9—偏差/方差、经验风险最小化、联合界、一致收敛 公开课笔记10——VC维、模型选择、特征选择 公开课笔记11——贝叶斯正则化、在线学习、ML应用建议 公开课笔记12——K-Means、混合高斯分布、EM算法 公开课笔记13A——混合高斯模型、混合贝叶斯模型 公开课笔记13B-因子分析模型及其EM求解 公开课笔记14——主成分分析 公开课笔记15—隐含语义索引、奇异值分解、独立成分分析
深度学习 softmax 函数的C语言和python实现
ZHE
10-28 1006
文章目录Softmax函数数字过大导致溢出问题解决python 实现C语言实现 Softmax函数 softmax 在深度学习分类任务中常被用于最后一层输出每个类别的概率，其公式如下： σ(z)j=ezj∑k=1Kezzk\sigma(z)_j = \frac{e^{z_j}}{\sum_{k=1}^{K}e^{z^{z_k}}}σ(z)j​=∑k=1K​ezzk​ezj​​ zj z_...
李沐深度学习-03.05softmax简洁实现
最新发布
qq_44972941的博客
10-09 90
softmax简洁实现
softmax原理讲解与python代码实现
weixin_50744311的博客
07-04 2136
本文讲解了softmax回归的原理与公式，并通过python实现了使用其进行分类，效果很好
softmax的实现
m0_61414335的博客
04-15 899
此时需要x*y个w，对于样本，需要计算其类别的可能性，进行y次线性运算。遍历训练数据集中的每个批次，计算模型在输入 x下的输出 y_hat，然后计算模型输出和真实标签之间的损失 l。对于data_iter中的x,y，经过net预测后的x与实际值y相同则加入metric,返回值为正确率。softmax是为了实现分类问题而提出，设在某一问题中，样本有x个特征，分类的结果有y类，函数的目的是对模型进行训练和参数更新，并在每个 epoch 后评估模型在测试集上的准确率。先输入张量X进行指数运算，得到一个新的张量。
信号分类 搭建RNN深度学习神经网络代码
05-21
以下是一个简单的例子，用于对信号进行分类的 RNN 深度学习神经网络代码： ``` python import numpy as np from keras.utils import np_utils from keras.models import Sequential from keras.layers import Dense...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值