神经网络学习（四）

最新推荐文章于 2021-10-17 21:50:58 发布
最新推荐文章于 2021-10-17 21:50:58 发布
阅读量383 收藏 1
点赞数
分类专栏： 神经网络 文章标签： 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34445388/article/details/106185401
版权

神经网络学习（四）

上一篇我们推导和实验了使用交叉熵作为损失函数能够明显提高神经网络训练的精度和速度，但是为什么呢？这一篇就结合我再在网上看到的资料进行一个探索。

假设

  • 样本维度是2维
  • 分类结果有三类
  • 一种两个样本 ( x 11 , x 12 , y 1 ) , ( x 21 , x 22 , y 2 ) (x_{11},x_{12},y_1),(x_{21},x_{22},y_2) (x11​,x12​,y1​),(x21​,x22​,y2​)

公式推导

前向传播

和之前的推导类似，前向传播公式：
输出层使用softmax的公式：
z 1 = ω 11 x 1 + ω 12 x 2 + b 1 z 2 = ω 21 x 1 + ω 22 x 2 + b 2 z 3 = ω 31 x 1 + ω 32 x 2 + b 3 a 1 = e z 1 e z 1 + e z 2 + e z 3 a 2 = e z 2 e z 1 + e z 2 + e z 3 a 3 = e z 3 e z 1 + e z 2 + e z 3 \begin{aligned} z_1 &= \omega_{11}x_1+ \omega_{12}x_2+b_1 \\ z_2 &= \omega_{21}x_1+ \omega_{22}x_2+b_2 \\ z_3 &= \omega_{31}x_1+ \omega_{32}x_2+b_3 \\ a_1 &= \frac{e^{z_1}}{e^{z_1}+e^{z_2}+e^{z_3}} \\ a_2 &= \frac{e^{z_2}}{e^{z_1}+e^{z_2}+e^{z_3}} \\ a_3 &= \frac{e^{z_3}}{e^{z_1}+e^{z_2}+e^{z_3}} \\ \end{aligned} z1​z2​z3​a1​a2​a3​​=ω11​x1​+ω12​x2​+b1​=ω21​x1​+ω22​x2​+b2​=ω31​x1​+ω32​x2​+b3​=ez1​+ez2​+ez3​ez1​​=ez1​+ez2​+ez3​ez2​​=ez1​+ez2​+ez3​ez3​​​
输出层使用sigmoid的公式：
z 1 = ω 11 x 1 + ω 12 x 2 + b 1 z 2 = ω 21 x 1 + ω 22 x 2 + b 2 z 3 = ω 31 x 1 + ω 32 x 2 + b 3 a 1 = 1 1 + e z 1 a 2 = 1 1 + e z 2 a 3 = 1 1 + e z 3 \begin{aligned} z_1 &= \omega_{11}x_1+ \omega_{12}x_2+b_1 \\ z_2 &= \omega_{21}x_1+ \omega_{22}x_2+b_2 \\ z_3 &= \omega_{31}x_1+ \omega_{32}x_2+b_3 \\ a_1 &= \frac{1}{1+e^{z_1}} \\ a_2 &= \frac{1}{1+e^{z_2}} \\ a_3 &= \frac{1}{1+e^{z_3}} \\ \end{aligned} z1​z2​z3​a1​a2​a3​​=ω11​x1​+ω12​x2​+b1​=ω21​x1​+ω22​x2​+b2​=ω31​x1​+ω32​x2​+b3​=1+ez1​1​=1+ez2​1​=1+ez3​1​​
使用交叉熵损失函数：
E = y 1 log a 1 + y 2 log a 2 + y 3 log a 3 \begin{aligned} E=y_1\text{log} a_1+y_2\text{log} a_2 +y_3\text{log}a_3 \end{aligned} E=y1​loga1​+y2​loga2​+y3​loga3​​
使用平方误差损失函数：
E = 1 2 [ ( y 1 − a 1 ) 2 + ( y 2 − a 2 ) 2 + ( y 3 − a 3 ) 2 ] \begin{aligned} E=\frac{1}{2}\left[(y_1-a_1)^2+(y_2-a_2)^2+(y_3-a_3)^2\right] \end{aligned} E=21​[(y1​−a1​)2+(y2​−a2​)2+(y3​−a3​)2]​

反向传播

我们反向传播是为了看损失函数对神经网络的权值的影响，因此这里只求对 ω 11 \omega_{11} ω11​的影响，别的可以以此类推
对于平方误差损失函数，有我之前神经网络学习（二）的结论可以写出：
∂ E ∂ ω 11 = − ( y 1 − a 1 ) a 1 ( 1 − a 1 ) x 11 \begin{aligned} \frac{\partial E}{\partial \omega_{11}}=-(y_1-a_1)a_1(1-a_1)x_{11} \end{aligned} ∂ω11​∂E​=−(y1​−a1​)a1​(1−a1​)x11​​
**我们要明确，在使用平方误差损失函数时我们的目的是什么？**我们是想知道 ∇ ω 11 \nabla \omega_{11} ∇ω11​和误差 y 1 − a 1 y_1-a_1 y1​−a1​的关系，即 ∇ ω 11 = f ( y 1 − a 1 ) \nabla \omega_{11}=f(y_1-a_1) ∇ω11​=f(y1​−a1​)
我们知道 y 1 y_1 y1​的取值只能是0或1，而a_1的取值范围是 0 ∼ 1 0\sim 1 0∼1。
取 A = ∣ y 1 − a 1 ∣ A=|y_1-a_1| A=∣y1​−a1​∣
当 y 1 = 1 y_1=1 y1​=1时， A = y 1 − a 1 A=y_1-a_1 A=y1​−a1​， a 1 = y 1 − A a_1=y_1-A a1​=y1​−A带入上式得
∂ E ∂ ω 11 = − A ( y 1 − A ) ( 1 − ( y 1 − A ) ) x 11 = − A 2 ( 1 − A ) x 11 \begin{aligned} \frac{\partial E}{\partial \omega_{11}}=-A(y_1-A)(1-(y_1-A))x_{11}=-A^2(1-A)x_{11} \end{aligned} ∂ω11​∂E​=−A(y1​−A)(1−(y1​−A))x11​=−A2(1−A)x11​​
当 y 1 = 0 y_1=0 y1​=0时， A = a 1 A=a_1 A=a1​，带入上式得
∂ E ∂ ω 11 = − ( − A ) A ( 1 − A ) x 11 = A 2 ( 1 − A ) x 11 \begin{aligned} \frac{\partial E}{\partial \omega_{11}}=-(-A)A(1-A)x_{11}=A^2(1-A)x_{11} \end{aligned} ∂ω11​∂E​=−(−A)A(1−A)x11​=A2(1−A)x11​​
上面的推导中 x 11 x_{11} x11​是样本，在训练中是常量，只有误差A是变量，因此 A 2 ( 1 − A ) A^2(1-A) A2(1−A)是参数更新的因素

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

A = np.linspace(0, 1, 100)
plt.plot(A, A ** 2 * (1 - A))
plt.xlabel("|error|")
plt.ylabel("$\delta w_{11}$")
plt.title("$\delta w_{11}$=f(A)")
plt.show()

在这里插入图片描述
从上图可以看出，当误差不断增大的时候，更新的参数先变大后变小，也就是说当误差太大的时候，反向传播变慢，乃至可能停止，这个是跟我们的期望相反，我们期望的是向误差小的地方移动，并且误差越大移动越快。
对于交叉熵损失函数，有我之前神经网络学习（三）的结论可以写出：
∂ E ∂ ω 11 = a 1 − y 1 \begin{aligned} \frac{\partial E}{\partial \omega_{11}}=a_1-y_1 \end{aligned} ∂ω11​∂E​=a1​−y1​​
当 y 1 = 1 y_1=1 y1​=1时， A = y 1 − a 1 A=y_1-a_1 A=y1​−a1​， a 1 = y 1 − A a_1=y_1-A a1​=y1​−A带入上式得:
∂ E ∂ ω 11 = − A \begin{aligned} \frac{\partial E}{\partial \omega_{11}}=-A \end{aligned} ∂ω11​∂E​=−A​
当 y 1 = 0 y_1=0 y1​=0时， A = a 1 A=a_1 A=a1​，带入上式得:
∂ E ∂ ω 11 = A \begin{aligned} \frac{\partial E}{\partial \omega_{11}}=A \end{aligned} ∂ω11​∂E​=A​
此时，就可以之间看出，交叉熵损失函数中误差和参数更新完全是线性关系，服务我们对参数更新的期望。

实验验证

对刚刚的分析仅仅是理论的分析，下面可以把实验中的数据打印出来，验证我们的猜想。

交叉熵代价函数
import numpy as np
from sklearn.datasets import load_digits  #导入手写数字数据集
from sklearn.preprocessing import LabelBinarizer  # 标签二值化
from sklearn.model_selection import train_test_split  # 切割数据,交叉验证法
import matplotlib.pyplot as plt

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


def dsigmoid(x):
    return x * (1 - x)

def softmax(x):
    sum = 0
    temp = np.zeros(len(x[0]))
    for i in range(len(x[0])):
        sum += np.exp(x[0][i]) 
        
    for i in range(len(x[0])):
        temp[i] = np.exp(x[0][i]) / sum 
        
    temp = np.atleast_2d(temp)
    return temp 
    

class NeuralNetwork:
    def __init__(self, layers):  # (64,100,10)
        # 权重的初始化,范围-1到1：+1的一列是偏置值
        self.V = np.random.random((layers[0] + 1, layers[1] + 1)) * 2 - 1
        self.W = np.random.random((layers[1] + 1, layers[2])) * 2 - 1

    def train(self, X, y, lr=0.11, epochs=10000):
        # 添加偏置值：最后一列全是1
        temp = np.ones([X.shape[0], X.shape[1] + 1])
        temp[:, 0:-1] = X
        X = temp

        for n in range(epochs + 1):
            # 在训练集中随机选取一行(一个数据)：randint()在范围内随机生成一个int类型
            i = np.random.randint(X.shape[0])
            x = [X[i]]
            # 转为二维数据：由一维一行转为二维一行
            x = np.atleast_2d(x)

            # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
            # L2：隐藏层传递到输出层的值；输出层10个节点
            L1 = sigmoid(np.dot(x, self.V))
            L2 = softmax(np.dot(L1, self.W))
            # L2_delta：输出层对隐藏层的误差改变量
            # L1_delta：隐藏层对输入层的误差改变量
            Error.append(np.abs(y[i][0] - L2[0][0]))
            L2_delta = y[i] - L2
            gradient.append(L2_delta[0][0])
            L1_delta = L2_delta.dot(self.W.T) * dsigmoid(L1)
            #print(L2)
            # 计算改变后的新权重
            self.W += lr * L1.T.dot(L2_delta)
            self.V += lr * x.T.dot(L1_delta)
            if n > 40000:
                lr = lr * 0.99
            # 每训练1000次输出一次准确率
            if n % 1000 == 0:
                predictions = []
                for j in range(X_test.shape[0]):
                    # 获取预测结果：返回与十个标签值逼近的距离，数值最大的选为本次的预测值
                    o = self.predict(X_test[j])
                    # 将最大的数值所对应的标签返回
                    predictions.append(np.argmax(o))
                # np.equal()：相同返回true，不同返回false
                accuracy = np.mean(np.equal(predictions, y_test))
                print('迭代次数：', n, '准确率：', accuracy)

    def predict(self, x):
        # 添加偏置值：最后一列全是1
        temp = np.ones([x.shape[0] + 1])
        temp[0:-1] = x
        x = temp
        # 转为二维数据：由一维一行转为二维一行
        x = np.atleast_2d(x)

        # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
        # L2：隐藏层传递到输出层的值；输出层10个节点
        L1 = sigmoid(np.dot(x, self.V))
        L2 = softmax(np.dot(L1, self.W))
        return L2
# 载入数据:8*8的数据集
digits = load_digits()
X = digits.data
Y = digits.target
# 输入数据归一化：当数据集数值过大，乘以较小的权重后还是很大的数，代入sigmoid激活函数就趋近于1，不利于学习
X -= X.min()
X /= X.max()

NN = NeuralNetwork([64, 80, 10])
# sklearn切分数据
X_train, X_test, y_train, y_test = train_test_split(X, Y)
# 标签二值化：将原始标签(十进制)转为新标签(二进制)
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)
global Error 
global gradient 
Error = []
gradient = []
print('开始训练')
NN.train(X_train, labels_train, epochs=40000)
print('训练结束')
plt.plot(Error, gradient,".")

在这里插入图片描述
可以看出误差和梯度是标准的线性关系，并且是其实在误差特别大的点并不是很多。

平方误差代价函数
import numpy as np
from sklearn.datasets import load_digits  #导入手写数字数据集
from sklearn.preprocessing import LabelBinarizer  # 标签二值化
from sklearn.model_selection import train_test_split  # 切割数据,交叉验证法
import matplotlib.pyplot as plt

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


def dsigmoid(x):
    return x * (1 - x)

def softmax(x):
    sum = 0
    temp = np.zeros(len(x[0]))
    for i in range(len(x[0])):
        sum += np.exp(x[0][i]) 
        
    for i in range(len(x[0])):
        temp[i] = np.exp(x[0][i]) / sum 
        
    temp = np.atleast_2d(temp)
    return temp 
    

class NeuralNetwork:
    def __init__(self, layers):  # (64,100,10)
        # 权重的初始化,范围-1到1：+1的一列是偏置值
        self.V = np.random.random((layers[0] + 1, layers[1] + 1)) * 2 - 1
        self.W = np.random.random((layers[1] + 1, layers[2])) * 2 - 1

    def train(self, X, y, lr=0.11, epochs=10000):
        # 添加偏置值：最后一列全是1
        temp = np.ones([X.shape[0], X.shape[1] + 1])
        temp[:, 0:-1] = X
        X = temp

        for n in range(epochs + 1):
            # 在训练集中随机选取一行(一个数据)：randint()在范围内随机生成一个int类型
            i = np.random.randint(X.shape[0])
            x = [X[i]]
            # 转为二维数据：由一维一行转为二维一行
            x = np.atleast_2d(x)

            # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
            # L2：隐藏层传递到输出层的值；输出层10个节点
            L1 = sigmoid(np.dot(x, self.V))
            L2 = sigmoid(np.dot(L1, self.W))

            # L2_delta：输出层对隐藏层的误差改变量
            # L1_delta：隐藏层对输入层的误差改变量
            L2_delta = (y[i] - L2) * dsigmoid(L2)
            L1_delta = L2_delta.dot(self.W.T) * dsigmoid(L1)
            Error.append(np.abs(y[i][0] - L2[0][0]))
            gradient.append(L2_delta[0][0])
            #print(L2)
            # 计算改变后的新权重
            self.W += lr * L1.T.dot(L2_delta)
            self.V += lr * x.T.dot(L1_delta)
            if n > 40000:
                lr = lr * 0.99
            # 每训练1000次输出一次准确率
            if n % 1000 == 0:
                predictions = []
                for j in range(X_test.shape[0]):
                    # 获取预测结果：返回与十个标签值逼近的距离，数值最大的选为本次的预测值
                    o = self.predict(X_test[j])
                    # 将最大的数值所对应的标签返回
                    predictions.append(np.argmax(o))
                # np.equal()：相同返回true，不同返回false
                accuracy = np.mean(np.equal(predictions, y_test))
                print('迭代次数：', n, '准确率：', accuracy)

    def predict(self, x):
        # 添加偏置值：最后一列全是1
        temp = np.ones([x.shape[0] + 1])
        temp[0:-1] = x
        x = temp
        # 转为二维数据：由一维一行转为二维一行
        x = np.atleast_2d(x)

        # L1：输入层传递给隐藏层的值；输入层64个节点，隐藏层100个节点
        # L2：隐藏层传递到输出层的值；输出层10个节点
        L1 = sigmoid(np.dot(x, self.V))
        L2 = softmax(np.dot(L1, self.W))
        return L2
# 载入数据:8*8的数据集
digits = load_digits()
X = digits.data
Y = digits.target
# 输入数据归一化：当数据集数值过大，乘以较小的权重后还是很大的数，代入sigmoid激活函数就趋近于1，不利于学习
X -= X.min()
X /= X.max()

NN = NeuralNetwork([64, 80, 10])
# sklearn切分数据
X_train, X_test, y_train, y_test = train_test_split(X, Y)
# 标签二值化：将原始标签(十进制)转为新标签(二进制)
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)
global Error 
global gradient 
Error = []
gradient = []
print('开始训练')
NN.train(X_train, labels_train, epochs=40000)
print('训练结束')
plt.plot(Error, gradient,".")

在这里插入图片描述
此时就可以看到，误差和梯度不是一个线性的变化，而且误差分布在较大的地方的密集程度是比交叉熵的明显增多的。

WanderingSIN
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实验四 手写数字识别的神经网络算法设计与实现
yhx_cjw的博客
11-21 1190
一、实验目的 通过学习BP神经网络技术，对手写数字进行识别，基于结构的识别法及模板匹配法来提高识别率。 二、实验器材 PC机 matlab软件 三、实验内容 按照BP神经网络设计方法选用两层BP网络，构造训练样本集，并构成训练所需的输入矢量和目标向量，通过画图工具，获得数字原始图像，截取图像像素为0的最大矩形区域，经过集合变换，变成16*16的二值图像，再进行反色处理，其图像数据特征提取为神经网络的输入向量。通过实验证实，BP神经网络应用于手写数字识别具有较高的识别率和可靠性。 四、...
神经网络与深度学习笔记（三）
cgd_lucky的博客
01-29 490
神经网络与深度学习笔记（三） 神经网络与深度学习笔记（三） 1 卷积神经网络 1.1 计算机视觉 1.2 边缘检测 1.3 Padding 1.4 Strided Convolutions 1.5 简单卷积层网络示例 1.5.1 池化层 1.5.2 卷积神经网络结构 2 Classical Networks 3 ResNet 3.1 identity block 3.2 The convolutional block 4 CNN的简单应用 4.1 车辆识别 4.2 神经风格迁移
BP神经网络及其应用【神经网络四】
M-博客
09-23 2643
BP神经网络典型案例分析 【例5-1】针对采集到的60组汽油样品，利用傅里叶近红外变换光谱仪对其进行扫描，扫描范围为900～1700nm，扫描间隔为2nm，每个样品的光谱曲线共含401个波长点。同时，利用传统实验室检测方法测定其辛烷值含量。现要求利用BP神经网络及RBF神经网络分别建立汽油样品近红外光谱及其辛烷值之间的数学模型，并对模型的性能进行评价。 其实现的MATLAB代码如下： >> clear all; %%训练集/测试集的产生 load spectra_data.mat %随机产生训练
关于深度学习神经网络模型训练，参数过大，导致显卡内存溢出问题的总结
qq_41166909的博客
10-17 1万+
实验是利用LeNet-5模型,计算手写数字集得误差。结果刚加载模型显卡内存就溢出。 报错如下： 先用keras来计算网络的大小，参数的个数。 (50000, 32, 32, 3) (50000,) (10000, 32, 32, 3) (10000,) sample: (512, 32, 32, 3) (512,) tf.Tensor(-1.0, shape=(), dtype=float32) tf.Tensor(1.0, shape=(), dtype=float32) Model: "re
【深度学习】4：BP神经网络+sklearn实现手写数字识别
zzZ_CMing的博客
01-27 1万+
前言：上一篇【深度学习】3：BP神经网络识别MNIST数据集程序跑的太慢了，而且占内存很大，所以再介绍一篇BP神经网络+sklearn做图片识别的程序。大家仅供参考。 –—-—-—-—-—-—-—-—-—-—-—-—–—-—-—-—-—-—-—-——-—-—-—-—-—-—-—-—-—-—-—-—-—-——- –—-—-—-—-—-—-—-—-—-—-—-—–—-—-—-—-—-—-—-——-—
机器学习之卷积神经网络学习
06-28
"机器学习之卷积神经网络学习" 本文将详细介绍卷积神经网络（Convolutional Neural Networks，CNN）的基本概念和工作原理。卷积神经网络是一种深度学习模型，常用于图像识别、目标检测和图像分割等领域。 一、神经...
神经网络学习建议
10-31
以下是一些关于神经网络学习的建议，帮助你逐步建立对这个领域的深入理解。 首先，推荐从吴恩达教授的机器学习课程入手。吴恩达是斯坦福大学的教授，他在Coursera上的课程是全球最受欢迎的在线教育课程之一。他的...
山东大学软件学院机器学习实验四 BP神经网络
04-19
山东大学机器学习实验代码思路，没有套用框架的BP神经网络源码。输入数据是老师给的那个400*5000的数据集，这个神经网络在这个数据集的表现正确率基本为95左右。
神经网络学习 之 BP神经网络.pdf
03-20
BP神经网络学习笔记 BP神经网络是神经网络学习中的一种重要算法，以下是BP神经网络的详细知识点： 第一章 概述 BP神经网络是反馈神经网络的一种， BP全称为Back Propagation，意为反向传播算法。BP神经网络是一种...
预测模型之神经网络：深度学习面面观
最新发布
09-25
预测模型之神经网络：深度学习面面观 在人工智能（AI）和机器学习领域中，神经网络和深度学习是两个紧密相关的概念，它们都是机器学习的重要分支。下面我们将深入探讨神经网络和深度学习的概念、类型和应用。 一、...
sigmoid函数_温故知新——激活函数及其各自的优缺点
weixin_39945445的博客
11-22 4944
1.什么是激活函数？所谓激活函数（Activation Function），就是在人工神经网络的神经元上运行的函数，负责将神经元的输入映射到输出端。激活函数对于人工神经网络模型去学习、理解非常复杂和非线性的函数来说具有十分重要的作用。它们将非线性特性引入到我们的网络中。如图，在神经元中，输入（inputs ）通过加权，求和后，还被作用在一个函数上，这个函数就是激活函数。2.为什么要用激活函数？如果...
Tensorflow之神经网络nn模块详解
Never-Giveup的博客
07-18 1万+
Tensorflow中的tensorflow.nn模块是TensorFlow用于深度学习计算的核心模块。 主要的API: 激活函数（Activation Functions） 操作 描述 tf.nn.relu(features, name=None) 整流函数：max(features, 0) tf.nn.relu6(features, name=Non...
神经网络学习笔记（四）
qq_18515405的专栏
11-14 4763
一组连接（类比于生物神经元的树突），更准确的讲是一组输入。而每一个输入都会有一个权重进行作用。第k个神经元的第j个树突接收到的一个输入xj，那么这个输入将被权重wkj作用，其中下标表示第k个神经元的第j个树突的权重。
【PyTorch】卷积神经网络/Convolutional Neural Network（CNN）
积流成河
04-21 277
1 模型描述 卷积神经网络是用来处理图像识别的强大算法（之一） 模型针对的是MNIST手写数字的十分类问题 模型通过nn.Sequential构建两个卷积层 主要步骤包括卷积计算、ReLU、Maxpool、Softmax 输出层是线性的softmax，得到最大概率的分类作为结果 2 具体代码 # convolutional neural network import torch import torch.nn as nn import torchvision import torchvision.tr
神经网络关于训练集数据量越大，效果越好的误解
热门推荐
一点朱砂傲世风华
06-16 1万+
@TOC之前一直想不通为什么训练集为什么一直需要越大越好？通常来说，训练喂的数据越多，预测应该越好吧。最好，用交叉验证确认一下也有可能训练样本量大，数据特征较多，但网络层次太少，特征训练不充分，预测结果变差，这样才对啊。随着慢慢的学习，数据量越大效果越好，这前提是网络提取特征能力不能太差，效果的好坏是有多方面因素的。多方面因素我还没理解透每一方面具体的体现。如有不正确的，还望指教。嘻嘻，学无止境啊...
增大Batch训练神经网络：单GPU、多GPU及分布式配置的实用技巧
weixin_34342578的博客
10-28 473
2018年中的大部分时间，我都在尝试利用训练神经网络克服GPUs的局限。无论是在包含1.5亿个参数的语言模型中，比如OpenAI’s huge Generative Pre-trained Transformer (or the recent and similar BERT model)，还是在拥有3000万个输入元素的神经网络中，我都只能利用GPU处...
独家 | 你的神经网络不起作用的37个理由（附链接）
数据派THU
07-31 583
作者：Slav Ivanov翻译：吴金笛校对：丁楠雅本文约4400字，建议阅读12分钟。本文列举了在搭建神经网络过程中的37个易错点，并给出了解决建议。有一个网络已经训练...
【面向代码】学习 Deep Learning（一）Neural Network .
u010384318的专栏
07-25 1589
========================================================================================== 最近一直在看Deep Learning，各类博客、论文看得不少 但是说实话，这样做有些疏于实现，一来呢自己的电脑也不是很好，二来呢我目前也没能力自己去写一个toolbox 只是跟着Andrew Ng的UFLDL
自适应动态规划（二）
Wandering的博客
10-10 5152
自适应动态规划（二） 贝尔曼公式和离散LQR 一个离散系统 x(k+1)=Ax(k)+Bu(k) x(k+1)=Ax(k)+Bu(k) x(k+1)=Ax(k)+Bu(k) 性能指标函数 J(k)=12∑i=k∞(xT(i)Qx(i)+uT(i)Ru(i)) J(k)=\frac{1}{2}\sum_{i=k}^{\infty}(x^T(i)Qx(i)+u^T(i)Ru(i)) J(k)=21​i=k∑∞​(xT(i)Qx(i)+uT(i)Ru(i)) 由贝尔曼方程可知 V(x(k))=12∑i=k∞(xT

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值