AI 助理
备案控制台
开发者社区 人工智能 文章 正文

scikit-learn学习之神经网络算法

2017-06-25 2566
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：


目录(?)[+]

======================================================================

本系列博客主要参考 Scikit-Learn 官方网站上的每一个算法进行，并进行部分翻译，如有错误，请大家指正 

转载请注明出处，谢谢  

======================================================================


scikit-learn博主使用的是0.17版本，是稳定版，当然现在有0.18发行版，两者还是有区别的，感兴趣的可以自己官网上查看

scikit-learn0.17（and 之前）上对于Neural Network算法 的支持仅限于 BernoulliRBM

scikit-learn0.18上对于Neural Network算法有三个  neural_network.BernoulliRBM ，neural_network.MLPClassifier，neural_network.MLPRgression 

具体可参考：点击阅读


1：神经网络算法简介

2：Backpropagation算法详细介绍

3：非线性转化方程举例

4：自己实现神经网络算法NeuralNetwork

5：基于NeuralNetwork的XOR实例

6：基于NeuralNetwork的手写数字识别实例

7：scikit-learn中BernoulliRBM使用实例

8：scikit-learn中的手写数字识别实例


一：神经网络算法简介

1：背景

以人脑神经网络为启发，历史上出现过很多版本，但最著名的是backpropagation

2：多层向前神经网络（Multilayer  Feed-Forward Neural Network）

                                                          

多层向前神经网络组成部分

输入层（input layer），隐藏层（hiddenlayer），输出层（output layer）

   每层由单元（units）组成
   输入层（input layer）是由训练集的实例特征向量传入
   经过连接结点的权重（weight）传入下一层，一层的输出是下一层的输入
   隐藏层的个数是任意的，输出层和输入层只有一个
   每个单元（unit）也可以被称作神经结点，根据生物学来源定义
   上图称为2层的神经网络（输入层不算）
   一层中加权的求和，然后根据非线性的方程转化输出
   作为多层向前神经网络，理论上，如果有足够多的隐藏层（hidden layers）和足够大的训练集，可以模拟出任何方程

3：设计神经网络结构

    3.1使用神经网络训练数据之前，必须确定神经网络层数，以及每层单元个数
    3.2特征向量在被传入输入层时通常被先标准化（normalize）和0和1之间（为了加强学习过程）
    3.3离散型变量可以被编码成每一个输入单元对应一个特征可能赋的值
        比如：特征值A可能取三个值（a0,a1,a2），可以使用三个输入单元来代表A
                    如果A=a0,那么代表a0的单元值就取1，其他取0
                    如果A=a1,那么代表a1的单元值就取1，其他取0，以此类推
    3.4神经网络即可以用来做分类（classification）问题，也可以解决回归（regression）问题
         3.4.1对于分类问题，如果是2类，可以用一个输入单元表示（0和1分别代表2类）
                                         如果多于两类，每一个类别用一个输出单元表示
                所以输入层的单元数量通常等于类别的数量 
        3.4.2没有明确的规则来设计最好有多少个隐藏层
               3.4.2.1根据实验测试和误差，以及准确度来实验并改进

4：算法验证——交叉验证法（Cross- Validation）

解读： 有一组输入集A,B，可以分成三组，第一次以第一组为训练集，求出一个准确度，第二次以第二组作为训练集，求出一个准确度，求出准确度，第三次以第三组作为训练集，求出一个准确度，然后对三个准确度求平均值


二：Backpropagation算法详细介绍

                                                            


1：通过迭代性来处理训练集中的实例

2：输入层输入数

           经过权重计算得到第一层的数据，第一层的数据作为第二层的输入，再次经过权重计算得到结果，结果和真实值之间是存在误差的，然后根据误差，反向的更新每两个连接之间的权重

3：算法详细介绍

      输入：D : 数据集，| 学习率（learning rate），一个多层前向神经网络

    输出：一个训练好的神经网络（a trained neural network）
    3.1初始化权重（weights）和偏向（bias）：随机初始化在-1到1之间，或者-0.5到0.5之间，每个单元有一个偏向
    3.2对于每一个训练实例X，执行以下步骤：
         3.2.1：由输入层向前传送,输入->输出对应的计算为：
                              
                                         
                   计算得到一个数据，经过f 函数转化作为下一层的输入，f函数为：
          3.2.2：根据误差（error）反向传送
                     对于输出层（误差计算）：  Tj：真实值，Qj表示预测值
 
                     对于隐藏层（误差计算）：  Errk 表示前一层的误差， Wjk表示前一层与当前点的连接权重
                       
                     权重更新：  l：指学习比率（变化率），手工指定，优化方法是，随着数据的迭代逐渐减小
                     偏向更新：  l：同上
       3.3：终止条件
           3.3.1权重的更新低于某个阀值
           3.3.2预测的错误率低于某个阀值
           3.3.3达到预设一定的循环次数

4：结合实例讲解算法

                                                                  

                                                                  

                                                                

              0.9对用的是L，学习率


三：非线性转化方程举例

在二中Activation Function对计算结果进行转换，得到下一层的输入，这里用到的f函数就是非线性转换函数，Sigmoid函数（S曲线）用来做f函数，Sigmoid函数是一类函数，只要S曲线满足一定的性质就可以作为activation Function函数

Sigmoid函数：

                                                                       

常见的Sigmoid函数

1：双曲函数（参考百科，下面以tan函数为例）

                


双曲函数的导数为：

                                                         


2：逻辑函数（Logistic函数）

                                                                    

逻辑函数的导数形式为：

                                                             


四：自己实现神经网络算法NeuralNetwork

建立NeuralNetwork.py,添加以下代码

[python]  view plain  copy
  1. #coding:utf-8  
  2. ''''' 
  3. Created on 2016/4/27 
  4.  
  5. @author: Gamer Think 
  6. '''  
  7. import numpy as np  
  8.   
  9. #定义双曲函数和他们的导数  
  10. def tanh(x):  
  11.     return np.tanh(x)  
  12.   
  13. def tanh_deriv(x):  
  14.     return 1.0 - np.tanh(x)**2  
  15.   
  16. def logistic(x):  
  17.     return 1/(1 + np.exp(-x))  
  18.   
  19. def logistic_derivative(x):  
  20.     return logistic(x)*(1-logistic(x))  
  21.   
  22. #定义NeuralNetwork 神经网络算法  
  23. class NeuralNetwork:  
  24.     #初始化，layes表示的是一个list，eg[10,10,3]表示第一层10个神经元，第二层10个神经元，第三层3个神经元  
  25.     def __init__(self, layers, activation='tanh'):  
  26.         """ 
  27.         :param layers: A list containing the number of units in each layer. 
  28.         Should be at least two values 
  29.         :param activation: The activation function to be used. Can be 
  30.         "logistic" or "tanh" 
  31.         """  
  32.         if activation == 'logistic':  
  33.             self.activation = logistic  
  34.             self.activation_deriv = logistic_derivative  
  35.         elif activation == 'tanh':  
  36.             self.activation = tanh  
  37.             self.activation_deriv = tanh_deriv  
  38.   
  39.         self.weights = []  
  40.         #循环从1开始，相当于以第二层为基准，进行权重的初始化  
  41.         for i in range(1, len(layers) - 1):  
  42.             #对当前神经节点的前驱赋值  
  43.             self.weights.append((2*np.random.random((layers[i - 1] + 1, layers[i] + 1))-1)*0.25)  
  44.             #对当前神经节点的后继赋值  
  45.             self.weights.append((2*np.random.random((layers[i] + 1, layers[i + 1]))-1)*0.25)  
  46.       
  47.     #训练函数   ，X矩阵，每行是一个实例 ，y是每个实例对应的结果，learning_rate 学习率，   
  48.     # epochs，表示抽样的方法对神经网络进行更新的最大次数  
  49.     def fit(self, X, y, learning_rate=0.2, epochs=10000):  
  50.         X = np.atleast_2d(X) #确定X至少是二维的数据  
  51.         temp = np.ones([X.shape[0], X.shape[1]+1]) #初始化矩阵  
  52.         temp[:, 0:-1] = X  # adding the bias unit to the input layer  
  53.         X = temp  
  54.         y = np.array(y) #把list转换成array的形式  
  55.   
  56.         for k in range(epochs):  
  57.             #随机选取一行，对神经网络进行更新  
  58.             i = np.random.randint(X.shape[0])   
  59.             a = [X[i]]  
  60.   
  61.             #完成所有正向的更新  
  62.             for l in range(len(self.weights)):  
  63.                 a.append(self.activation(np.dot(a[l], self.weights[l])))  
  64.             #  
  65.             error = y[i] - a[-1]  
  66.             deltas = [error * self.activation_deriv(a[-1])]  
  67.   
  68.             #开始反向计算误差，更新权重  
  69.             for l in range(len(a) - 2, 0, -1): # we need to begin at the second to last layer  
  70.                 deltas.append(deltas[-1].dot(self.weights[l].T)*self.activation_deriv(a[l]))  
  71.             deltas.reverse()  
  72.             for i in range(len(self.weights)):  
  73.                 layer = np.atleast_2d(a[i])  
  74.                 delta = np.atleast_2d(deltas[i])  
  75.                 self.weights[i] += learning_rate * layer.T.dot(delta)  
  76.       
  77.     #预测函数              
  78.     def predict(self, x):  
  79.         x = np.array(x)  
  80.         temp = np.ones(x.shape[0]+1)  
  81.         temp[0:-1] = x  
  82.         a = temp  
  83.         for l in range(0, len(self.weights)):  
  84.             a = self.activation(np.dot(a, self.weights[l]))  
  85.         return a  


五：基于NeuralNetwork的XOR（异或）示例

代码如下：

[python]  view plain  copy
  1. <span style="font-size:18px;">#coding:utf-8  
  2. ''''' 
  3. Created on 2016/4/27 
  4.  
  5. @author: Gamer Think 
  6. '''  
  7.   
  8. import numpy as np  
  9. from NeuralNetwork import NeuralNetwork  
  10. ''''' 
  11. [2,2,1] 
  12. 第一个2:表示 数据的纬度，因为是二维的，表示两个神经元，所以是2 
  13. 第二个2：隐藏层数据纬度也是2，表示两个神经元  
  14. 1：表示输入为一个神经元 
  15. tanh:表示用双曲函数里的tanh函数 
  16. '''  
  17. nn = NeuralNetwork([2,2,1], 'tanh')  
  18. X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  
  19. y = np.array([0, 1, 1, 0])  
  20. nn.fit(X, y)  
  21. for i in [[0, 0], [0, 1], [1, 0], [1,1]]:  
  22.     print(i,nn.predict(i)) </span>  


输出结果：

([0, 0], array([ 0.02150876]))
([0, 1], array([ 0.99857695]))
([1, 0], array([ 0.99859837]))
([1, 1], array([ 0.04854689]))


六：基于NeuralNetwork的手写数字识别示例

代码如下：


[python]  view plain  copy
  1. <span style="font-size:18px;">import numpy as np  
  2. from sklearn.datasets import load_digits  
  3. from sklearn.metrics import confusion_matrix,classification_report  
  4. from sklearn.preprocessing import LabelBinarizer  
  5. from sklearn.cross_validation import train_test_split  
  6. from NeuralNetwork import NeuralNetwork  
  7.   
  8. digits = load_digits()  
  9. X = digits.data  
  10. y = digits.target  
  11. X -= X.min()  
  12. X /= X.max()  
  13.   
  14. nn =NeuralNetwork([64,100,10],'logistic')  
  15. X_train, X_test, y_train, y_test = train_test_split(X, y)  
  16. labels_train = LabelBinarizer().fit_transform(y_train)  
  17. labels_test = LabelBinarizer().fit_transform(y_test)  
  18. print "start fitting"  
  19. nn.fit(X_train,labels_train,epochs=3000)  
  20. predictions = []  
  21. for i in range(X_test.shape[0]):  
  22.     o = nn.predict(X_test[i])  
  23.     predictions.append(np.argmax(o))  
  24. print confusion_matrix(y_test, predictions)  
  25. print classification_report(y_test, predictions) </span>  

输出结果：



七：scikit-learn中的BernoulliRBM使用实例

[python]  view plain  copy
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">from sklearn.neural_network import BernoulliRBM  
  2. X = [[0,0],[1,1]]  
  3. y = [0,1]  
  4. clf = BernoulliRBM().fit(X,y)  
  5. print clf</span>  

输出结果为：

BernoulliRBM(batch_size=10, learning_rate=0.1, n_components=256, n_iter=10,
       random_state=None, verbose=0)


注意此模块不支持predict函数，这与以往的算法有很大的不同


八：scikit-learn中的手写数字识别实例


[python]  view plain  copy
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">import numpy as np  
  2. import matplotlib.pyplot as plt  
  3.   
  4. from scipy.ndimage import convolve  
  5. from sklearn import linear_model, datasets, metrics  
  6. from sklearn.cross_validation import train_test_split  
  7. from sklearn.neural_network import BernoulliRBM  
  8. from sklearn.pipeline import Pipeline  
  9.   
  10.   
  11. ###############################################################################  
  12. # Setting up  
  13.   
  14. def nudge_dataset(X, Y):  
  15.     """ 
  16.     This produces a dataset 5 times bigger than the original one, 
  17.     by moving the 8x8 images in X around by 1px to left, right, down, up 
  18.     """  
  19.     direction_vectors = [  
  20.         [[0, 1, 0],  
  21.          [0, 0, 0],  
  22.          [0, 0, 0]],  
  23.   
  24.         [[0, 0, 0],  
  25.          [1, 0, 0],  
  26.          [0, 0, 0]],  
  27.   
  28.         [[0, 0, 0],  
  29.          [0, 0, 1],  
  30.          [0, 0, 0]],  
  31.   
  32.         [[0, 0, 0],  
  33.          [0, 0, 0],  
  34.          [0, 1, 0]]]  
  35.   
  36.     shift = lambda x, w: convolve(x.reshape((8, 8)), mode='constant',  
  37.                                   weights=w).ravel()  
  38.     X = np.concatenate([X] +  
  39.                        [np.apply_along_axis(shift, 1, X, vector)  
  40.                         for vector in direction_vectors])  
  41.     Y = np.concatenate([Y for _ in range(5)], axis=0)  
  42.     return X, Y  
  43.   
  44. # Load Data  
  45. digits = datasets.load_digits()  
  46. X = np.asarray(digits.data, 'float32')  
  47. X, Y = nudge_dataset(X, digits.target)  
  48. X = (X - np.min(X, 0)) / (np.max(X, 0) + 0.0001)  # 0-1 scaling  
  49.   
  50. X_train, X_test, Y_train, Y_test = train_test_split(X, Y,  
  51.                                                     test_size=0.2,  
  52.                                                     random_state=0)  
  53.   
  54. # Models we will use  
  55. logistic = linear_model.LogisticRegression()  
  56. rbm = BernoulliRBM(random_state=0, verbose=True)  
  57.   
  58. classifier = Pipeline(steps=[('rbm', rbm), ('logistic', logistic)])  
  59.   
  60. ###############################################################################  
  61. # Training  
  62.   
  63. # Hyper-parameters. These were set by cross-validation,  
  64. # using a GridSearchCV. Here we are not performing cross-validation to  
  65. # save time.  
  66. rbm.learning_rate = 0.06  
  67. rbm.n_iter = 20  
  68. # More components tend to give better prediction performance, but larger  
  69. # fitting time  
  70. rbm.n_components = 100  
  71. logistic.C = 6000.0  
  72.   
  73. # Training RBM-Logistic Pipeline  
  74. classifier.fit(X_train, Y_train)  
  75.   
  76. # Training Logistic regression  
  77. logistic_classifier = linear_model.LogisticRegression(C=100.0)  
  78. logistic_classifier.fit(X_train, Y_train)  
  79.   
  80. ###############################################################################  
  81. # Evaluation  
  82.   
  83. print()  
  84. print("Logistic regression using RBM features:\n%s\n" % (  
  85.     metrics.classification_report(  
  86.         Y_test,  
  87.         classifier.predict(X_test))))  
  88.   
  89. print("Logistic regression using raw pixel features:\n%s\n" % (  
  90.     metrics.classification_report(  
  91.         Y_test,  
  92.         logistic_classifier.predict(X_test))))  
  93.   
  94. ###############################################################################  
  95. # Plotting  
  96.   
  97. plt.figure(figsize=(4.2, 4))  
  98. for i, comp in enumerate(rbm.components_):  
  99.     plt.subplot(10, 10, i + 1)  
  100.     plt.imshow(comp.reshape((8, 8)), cmap=plt.cm.gray_r,  
  101.                interpolation='nearest')  
  102.     plt.xticks(())  
  103.     plt.yticks(())  
  104. plt.suptitle('100 components extracted by RBM', fontsize=16)  
  105. plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)  
  106.   
  107. plt.show()</span>  

显示结果：





附：博主对于前边的原理其实很是明白了，但是对于scikit-learn实现手写数字识别系统这个代码优点迷乱，如果路过大神明白的，可以给小弟指点迷津


scikit-learn博主使用的是0.17版本，是稳定版，当然现在有0.18发行版，两者还是有区别的，感兴趣的可以自己官网上查看
[python]  view plain  copy
  1. <span style="font-family:Microsoft YaHei;font-size:18px;">import numpy as np  
  2. from sklearn.datasets import load_digits  
  3. from sklearn.metrics import confusion_matrix,classification_report  
  4. from sklearn.preprocessing import LabelBinarizer  
  5. from sklearn.cross_validation import train_test_split  
  6. from NeuralNetwork import NeuralNetwork  
  7.   
  8. digits = load_digits()  
  9. X = digits.data  
  10. y = digits.target  
  11. X -= X.min()  
  12. X /= X.max()  
  13.   
  14. nn =NeuralNetwork([64,100,10],'logistic')  
  15. X_train, X_test, y_train, y_test = train_test_split(X, y)  
  16. labels_train = LabelBinarizer().fit_transform(y_train)  
  17. labels_test = LabelBinarizer().fit_transform(y_test)  
  18. print "start fitting"  
  19. nn.fit(X_train,labels_train,epochs=3000)  
  20. predictions = []  
  21. for i in range(X_test.shape[0]):  
  22.     o = nn.predict(X_test[i])  
  23.     predictions.append(np.argmax(o))  
  24. print confusion_matrix(y_test, predictions)  
  25. print classification_report(y_test, predictions) </span>  

转载请注明出处 http://blog.csdn.net/gamer_gyt
文章标签：
算法
机器学习/深度学习
Python
关键词：
网络算法
神经网络算法
算法学习
算法神经网络
学习网络
yabmarlboro
目录
相关文章
java冯坚持
|
8天前
|
缓存 算法 Java
JVM知识体系学习六：JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
这篇文章详细介绍了Java虚拟机（JVM）中的垃圾回收机制，包括垃圾的定义、垃圾回收算法、堆内存的逻辑分区、对象的内存分配和回收过程，以及不同垃圾回收器的工作原理和参数设置。
java冯坚持
29 4
JVM知识体系学习六：JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
java冯坚持
|
9天前
|
算法
动态规划算法学习三：0-1背包问题
这篇文章是关于0-1背包问题的动态规划算法详解，包括问题描述、解决步骤、最优子结构性质、状态表示和递推方程、算法设计与分析、计算最优值、算法实现以及对算法缺点的思考。
java冯坚持
32 2
动态规划算法学习三：0-1背包问题
简简单单做算法
|
7天前
|
机器学习/深度学习 算法 数据挖掘
基于GWO灰狼优化的GroupCNN分组卷积网络时间序列预测算法matlab仿真
本项目展示了基于分组卷积神经网络（GroupCNN）和灰狼优化（GWO）的时间序列回归预测算法。算法运行效果良好，无水印展示。使用Matlab2022a开发，提供完整代码及详细中文注释。GroupCNN通过分组卷积减少计算成本，GWO则优化超参数，提高预测性能。项目包含操作步骤视频，方便用户快速上手。
简简单单做算法
20 1
简简单单做算法
|
8天前
|
机器学习/深度学习 算法 数据安全/隐私保护
基于WOA鲸鱼优化的GroupCNN分组卷积网络时间序列预测算法matlab仿真
本项目展示了一种基于WOA优化的GroupCNN分组卷积网络时间序列预测算法。使用Matlab2022a开发，提供无水印运行效果预览及核心代码（含中文注释）。算法通过WOA优化网络结构与超参数，结合分组卷积技术，有效提升预测精度与效率。分组卷积减少了计算成本，而WOA则模拟鲸鱼捕食行为进行优化，适用于多种连续优化问题。
简简单单做算法
24 1
子午s
|
8天前
|
机器学习/深度学习 人工智能 算法
【玉米病害识别】Python+卷积神经网络算法+人工智能+深度学习+计算机课设项目+TensorFlow+模型训练
玉米病害识别系统，本系统使用Python作为主要开发语言，通过收集了8种常见的玉米叶部病害图片数据集（'矮花叶病', '健康', '灰斑病一般', '灰斑病严重', '锈病一般', '锈病严重', '叶斑病一般', '叶斑病严重'），然后基于TensorFlow搭建卷积神经网络算法模型，通过对数据集进行多轮迭代训练，最后得到一个识别精度较高的模型文件。再使用Django搭建Web网页操作平台，实现用户上传一张玉米病害图片识别其名称。
子午s
22 0
【玉米病害识别】Python+卷积神经网络算法+人工智能+深度学习+计算机课设项目+TensorFlow+模型训练
java冯坚持
|
9天前
|
算法
动态规划算法学习四：最大上升子序列问题（LIS：Longest Increasing Subsequence）
这篇文章介绍了动态规划算法中解决最大上升子序列问题（LIS）的方法，包括问题的描述、动态规划的步骤、状态表示、递推方程、计算最优值以及优化方法，如非动态规划的二分法。
java冯坚持
37 0
动态规划算法学习四：最大上升子序列问题（LIS：Longest Increasing Subsequence）
简简单单做算法
|
2天前
|
机器学习/深度学习 算法 数据安全/隐私保护
基于贝叶斯优化卷积神经网络(Bayes-CNN)的多因子数据分类识别算法matlab仿真
本项目展示了贝叶斯优化在CNN中的应用，包括优化过程、训练与识别效果对比，以及标准CNN的识别结果。使用Matlab2022a开发，提供完整代码及视频教程。贝叶斯优化通过构建代理模型指导超参数优化，显著提升模型性能，适用于复杂数据分类任务。
简简单单做算法
12 0
阿旭算法与机器学习
|
4月前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】26.卷积神经网络之AlexNet模型介绍及其Pytorch实现【含完整代码】
【从零开始学习深度学习】26.卷积神经网络之AlexNet模型介绍及其Pytorch实现【含完整代码】
阿旭算法与机器学习
222 3
阿旭算法与机器学习
|
4月前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】28.卷积神经网络之NiN模型介绍及其Pytorch实现【含完整代码】
【从零开始学习深度学习】28.卷积神经网络之NiN模型介绍及其Pytorch实现【含完整代码】
阿旭算法与机器学习
125 2
WCGhost-Netsafe
|
2月前
|
机器学习/深度学习 PyTorch 算法框架/工具
PyTorch代码实现神经网络
这段代码示例展示了如何在PyTorch中构建一个基础的卷积神经网络（CNN）。该网络包括两个卷积层，分别用于提取图像特征，每个卷积层后跟一个池化层以降低空间维度；之后是三个全连接层，用于分类输出。此结构适用于图像识别任务，并可根据具体应用调整参数与层数。
WCGhost-Netsafe
78 9

热门文章

最新文章

  • 1
    神经网络梯度下降的三种学习方式
  • 2
    从头训练一个神经网络！教它学会莫奈风格作画！⛵
  • 3
    用纯Python实现循环神经网络RNN向前传播过程(吴恩达DeepLearning.ai作业)
  • 4
    【CVPR2020】ECA-Net:深度卷积神经网络的有效通道注意力
  • 5
    训练深度神经网络的时候需要注意的一些小技巧
  • 6
    我搭的神经网络不 work 该怎么办！看看这 11 条新手最容易犯的错误
  • 7
    手把手教你如何提高神经网络的性能
  • 8
    基于BP神经网络预测电力负荷（Matlab代码实现）
  • 9
    自组织特征映射神经网络-2|学习笔记
  • 10
    其他神经网络| 学习笔记
  • 1
    【免费】基于SOE算法的多时段随机配电网重构方法
    46
  • 2
    【免费】面向多微网网络结构设计的大规模二进制矩阵优化算法
    51
  • 3
    【免费】基于ADMM算法的多微网电能交互分布式运行策略（matlab代码）
    82
  • 4
    基于有序抖动块截断编码的水印嵌入和提取算法matlab仿真
    41
  • 5
    【智能算法】11种混沌映射算法+2种智能算法示范【鲸鱼WOA、灰狼GWO算法】
    184
  • 6
    深度学习算法简介（二）
    52
  • 7
    基于改进ISODATA算法的负荷场景曲线聚类（matlab代码）
    45
  • 8
    基于分布式ADMM算法的考虑碳排放交易的电力系统优化调度研究（matlab代码）
    53
  • 9
    【免费】基于模型预测算法的含储能微网双层能量管理模型(MATLAB)
    49
  • 10
    基于CCG算法的IEEE33配电网两阶段鲁棒优化调度matlab
    56

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 网络管理者必知-2分钟了解新出台的《网络安全法》
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • Session：更加安全、可靠的数据中心网络产品更新
  • Session：极简易用的全球化网络产品更新
  • Session：弹性、高可用、可观测的应用交付网络产品更新

    • 相关实验场景

    更多
  • 推荐系统入门之使用ALS算法实现打分预测
  • 欧拉图的构造性证明与算法实现
  • RSA密码算法设计与实现
  • RSA非对称加密算法
  • 使用阿里云容器服务和容器网络文件系统搭建WordPress网站
    • 下一篇
    AI助理直击要害，从繁复中提炼精华——使用CDN加速访问OSS存储的图片