多角度理解sigmoid，relu和tanh激活函数

最新推荐文章于 2024-07-09 23:15:27 发布
最新推荐文章于 2024-07-09 23:15:27 发布
阅读量2k 收藏 10
点赞数 3
文章标签： 算法 python 神经网络 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56531353/article/details/117877941
版权
  • sigmoid激活函数

函数表达式:

函数图像：

 通过该图，可以看出对于sigmoid激活函数的一下几个特点：

1.当输入大于零时，输出一定大于0.5

2.当输入超过6时，输出将会无限接近于1，该函数的辨别功能将会失效

3.函数的阈值在0，1之间

4.具有良好的对称性

根据上述几个特点，我们可以初步总结sigmoid函数的应用场景：sigmoid的输出在0和1之间，我们在二分类任务中，采用sigmoid的输出的事件概率，也就是当输出满足满足某一概率条件我们将其划分分类，所以sigmoid函数适合作为二分类问题的输出层。

下面通过几个角度更加深入的理解sigmoid函数：

一.通过生活中的实例解释sigmoid激活函数：

题目：已知某样本实验者的身高，体重，每日锻炼时长，猜测实验者的性别。

首先根据sigmoid的特性，即当输入大于6时函数将会基本失效，则我们设定评判身高体重和每日锻炼时长的最高分为6，这里先估计某人的身高为5，体重为4.4，腰围为4，锻炼时长为4.3

然后设置身高的权重为0.3，体重的权重为4.4，腰围的权重为0.2，锻炼时长的权重为0.2

对于阈值，设置0到0.6为女生，0.6到1为男生

通过如上计算，可以得到结果为0.96，则判断该人很有可能是男生。

但是经过笔者在多次计算后发现之前说的通过分值代替身高体重的方法输入的数值还是太大了，如果输入的数大部分在3左右，则最后得出基本都是在0.9以上，很难有较好的判别效果分类，所以下述中，使用厘米计算身高，吨计算体重，小时计算锻炼时长，先简化放弃腰围，再次计算。

在上述计算中，通过第一次计算将阈值分界点从0.5改到了0.62，于是判断出了性别。

通过上述实验可以看出，sigmoid激活函数适合于在输出层作为二分类实验，以输出结果。

二.通过bp神经网络代码实验sigmoid激活函数

sigmoid函数代码定义：

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

使用sigmoid激活函数实现bp神经网络的完整代码，该神经网络是通过前面的跳高成绩去预测下一次跳高是成功还是失败，其中1代表成功0代表失败：

import numpy as np


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


def main():
    # 14条数据
    data = np.array([
        [1, 0, 0, 1, 0, 1, 1, 1],
        [0, 0, 1, 1, 0, 0, 1, 0],
        [1, 1, 0, 1, 1, 1, 0, 1],
        [0, 1, 0, 1, 0, 0, 1, 1],
        [1, 0, 1, 1, 0, 1, 1, 1],
        [1, 1, 0, 0, 1, 1, 1, 0],
        [0, 0, 0, 1, 0, 0, 1, 1],
        [1, 0, 1, 1, 0, 1, 1, 1],
        [1, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 0, 0, 1, 0, 1, 1],
        [1, 0, 0, 1, 0, 1, 1, 0],
        [0, 0, 1, 1, 0, 1, 0, 1],
        [1, 0, 0, 1, 0, 0, 1, 1],
        [0, 1, 0, 1, 0, 1, 1, 1]])
    print("原始数据：\n", data)
    # 十四条数据的跳高成绩
    highJump = np.array(
        [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0])
    print("十四条数据的跳高成绩：\n", highJump)
    # 第十五条数据的输入
    data15 = np.array([0, 1, 0, 1, 1, 0, 1, 0])
    print("第十五条数据的输入：\n", data15)
    # 设置输入层与隐藏层之间的权值和阈值
    wInput = np.random.random(size=(6, 8)) / 10
    print("输入层与隐藏层之间的六组权值:\n", wInput)
    bInput = np.random.random(size=(6, 8)) / 10
    print("输入层与隐藏层之间的六组阈值:\n", bInput)
    # 设置隐藏层与输出层之间的权值和阈值
    wOutput = np.random.random(size=6) / 10
    print("隐藏层与输出层之间的一组权值", wOutput)
    bOutput = np.random.random(size=6) / 10
    print("隐藏层与输出层之间的一组阈值", bOutput)
    loss = 2
    count = 0
    while loss > 1.7489:
        count = count + 1
        loss = 0
        outputNode = []
        for i in range(0, 14):

            # 正向传播
            # 计算隐藏层节点输入
            hide = []
            for j in range(0, 6):
                hideNode = 0
                for k in range(0, 8):
                    hideNode = data[i, k] * wInput[j, k] + \
                               bInput[j, k] + hideNode
                #print(hideNode)
                hideNode = sigmoid(hideNode)  # 激活函数
                hide.append(hideNode)
            hide = np.array(hide)
            # print("隐藏层结点", hide)
            output = 0
            for j in range(0, 6):
                output = hide[j] * wOutput[j] + bOutput[j] + output
            output = sigmoid(output)
            outputNode.append(output)
            # print("输出层结点", output)
            loss = ((output - highJump[i]) * (output - highJump[i])) / 2 + loss
        outputNode = np.array(outputNode)
        # 反向传播
        # print("隐藏层结点", hide)
        for i in range(0, 14):
            # 隐藏层与输出层之间权值阈值更新
            wOutputLoss = []
            for j in range(0, 6):
                wOutputLoss.append((outputNode[i] - highJump[i]) *
                                   outputNode[i] * (1 - outputNode[i])
                                   * hide[j])
            wOutputLoss = np.array(wOutputLoss)
            # print("wOutputLoss", wOutputLoss)
            bOutputLoss = []
            for j in range(0, 6):
                bOutputLoss.append((outputNode[i] - highJump[i]) *
                                   outputNode[i] * (1 - outputNode[i]))
            bOutputLoss = np.array(bOutputLoss)
            # print("bOutputLoss", bOutputLoss)
            for j in range(0, 6):
                wOutput[j] = wOutput[j] - 0.1 * wOutputLoss[j]
                bOutput[j] = bOutput[j] - 0.1 * bOutputLoss[j]
            # print("隐藏层与输出层更新后权值和阈值", wOutput, bOutput)
            # 输入层与隐藏层之间权值更新
            wInputLoss = np.ones((6, 8)) * 0
            for j in range(0, 6):
                for k in range(0, 8):
                    wInputLoss[j][k] = ((outputNode[i] - highJump[i]) *
                                        outputNode[i] *
                                        (1 - outputNode[i]) * wOutput[j]
                                        * hide[j] * (1 - hide[j]) * data[i][k])
            wInputLoss = np.array(wInputLoss)
            # print("wIutputLoss", wInputLoss)
            bInputLoss = np.ones((6, 8)) * 0
            for j in range(0, 6):
                for k in range(0, 8):
                    bInputLoss[j][k] = ((outputNode[i] - highJump[i]) *
                                        outputNode[i] * (1 - outputNode[i]) *
                                        wOutput[j] * hide[j] * (1 - hide[j]))
            bInputLoss = np.array(bInputLoss)
            #print("bIutputLoss", bInputLoss)
            for j in range(0, 6):
                for k in range(0, 8):
                    wInput[j][k] = wInput[j][k] - 0.1 * wInputLoss[j][k]
                    bInput[j][k] = bInput[j][k] - 0.1 * bInputLoss[j][k]
            #print("输入层与隐藏层之间更新后的权值和阈值", wInput, bInput)
        print("输出", output)
        print("学习前的loss", loss)
        loss = 0
        for i in range(0, 14):
            # 正向传播
            # 计算隐藏层节点输入
            hide = []
            for j in range(0, 6):
                hideNode = 0
                for k in range(0, 8):
                    hideNode = data[i, k] * wInput[j, k] + \
                               bInput[j, k] + hideNode
                hideNode = sigmoid(hideNode)  # 激活函数
                hide.append(hideNode)
            hide = np.array(hide)
            output = 0
            for j in range(0, 6):
                output = hide[j] * wOutput[j] + bOutput[j] + output
            output = sigmoid(output)
            loss = ((output - highJump[i]) * (output - highJump[i])) / 2 + loss
        print("输出", output)
        print("学习后的loss", loss)

    # 预测
    hide = []
    for j in range(0, 6):
        hideNode = 0
        for k in range(0, 8):
            hideNode = data15[k] * wInput[j, k] + \
                       bInput[j, k] + hideNode
            hideNode = sigmoid(hideNode)  # 激活函数
        hide.append(hideNode)
    hide = np.array(hide)
    output = 0
    for j in range(0, 6):
        output = hide[j] * wOutput[j] + bOutput[j] + output
    output = sigmoid(output)
    print(output)
    print(loss)
    print(count)


if __name__ == '__main__':
    main()

该bp神经网络包括了带有八个神经元（也就是原始数据中的八个01成绩）的输入层，带有六个神经元的隐藏层和一个神经元的输出层。

运行代码后得到结果：

上图是该网络首次完成学习前后的输出以及损失

上图是在第297次学习前后的输出以及损失并输出了最终的输出和损失，可以看到最后输出小于0.5，预测在下一次测试中较为有可能失败的。

  • tanh激活函数

函数表达式：
 

函数图像：

 

Tanh函数也称为双曲正切函数，取值范围为[-1,1]。Tanh函数是 sigmoid 的变形，Tanh函数是 0 均值的，因此实际应用中 Tanh 会比 sigmoid 更好。

通过上图，结合sigmoid函数可以得到tanh函数的几个特点：

1.双曲正切函数，tanh函数输出以0为中心，区间为[−1,1]，tanh可以想象成两个sigmoid函数放在一起，性能要高于sigmoid函数

2.收敛速度相对于Sigmoid更快

3.但是仍然存在梯度饱和与exp计算的问题。

依据上述特点，可以初步总结tanh函数的应用场景：由于tanh是sigmoid的改进版，所以sigmoid函数的应用场景tanh也都可以用，而且tanh性能更加优异，所以在不确定激活函数的时候使用tanh进行尝试的优先级仅仅在relu之后，不同于sigmoid函数适用于输出层的特性，tanh函数还可以应用在隐层和更多的情况。

和之前一样下面通过两个角度更加输入的理解tanh函数

一.通过生活中的实例解释tanh激活函数：

使用之前的题目：已知某样本实验者的身高，体重，每日锻炼时长，猜测实验者的性别。

在上述阈值中可以判断出性别，tanh函数可以使用在sigmoid适用的场景。

二.通过bp神经网络代码实验tanh激活函数

tanh函数定义代码：

def tanh(x):
    return np.sinh(x)/np.cosh(x)

使用上文中的跳高预测代码，稍作修改得到如下代码：

import numpy as np


def tanh(x):
    return np.sinh(x)/np.cosh(x)


def main():
    # 14条数据
    data = np.array([
        [1, 0, 0, 1, 0, 1, 1, 1],
        [0, 0, 1, 1, 0, 0, 1, 0],
        [1, 1, 0, 1, 1, 1, 0, 1],
        [0, 1, 0, 1, 0, 0, 1, 1],
        [1, 0, 1, 1, 0, 1, 1, 1],
        [1, 1, 0, 0, 1, 1, 1, 0],
        [0, 0, 0, 1, 0, 0, 1, 1],
        [1, 0, 1, 1, 0, 1, 1, 1],
        [1, 1, 0, 1, 0, 1, 0, 1],
        [1, 0, 0, 0, 1, 0, 1, 1],
        [1, 0, 0, 1, 0, 1, 1, 0],
        [0, 0, 1, 1, 0, 1, 0, 1],
        [1, 0, 0, 1, 0, 0, 1, 1],
        [0, 1, 0, 1, 0, 1, 1, 1]])
    print("原始数据：\n", data)
    # 十四条数据的跳高成绩
    highJump = np.array(
        [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0])
    print("十四条数据的跳高成绩：\n", highJump)
    # 第十五条数据的输入
    data15 = np.array([0, 1, 0, 1, 1, 0, 1, 0])
    print("第十五条数据的输入：\n", data15)
    # 设置输入层与隐藏层之间的权值和阈值
    wInput = np.random.random(size=(6, 8)) / 10
    print("输入层与隐藏层之间的六组权值:\n", wInput)
    bInput = np.random.random(size=(6, 8)) / 10
    print("输入层与隐藏层之间的六组阈值:\n", bInput)
    # 设置隐藏层与输出层之间的权值和阈值
    wOutput = np.random.random(size=6) / 10
    print("隐藏层与输出层之间的一组权值", wOutput)
    bOutput = np.random.random(size=6) / 10
    print("隐藏层与输出层之间的一组阈值", bOutput)
    loss = 2
    count = 0
    while loss < 2.1:
        count = count + 1
        loss = 0
        outputNode = []
        for i in range(0, 14):

            # 正向传播
            # 计算隐藏层节点输入
            hide = []
            for j in range(0, 6):
                hideNode = 0
                for k in range(0, 8):
                    hideNode = data[i, k] * wInput[j, k] + \
                               bInput[j, k] + hideNode
                #print(hideNode)
                hideNode = tanh(hideNode)  # 激活函数
                hide.append(hideNode)
            hide = np.array(hide)
            # print("隐藏层结点", hide)
            output = 0
            for j in range(0, 6):
                output = hide[j] * wOutput[j] + bOutput[j] + output
            output = tanh(output)
            outputNode.append(output)
            # print("输出层结点", output)
            loss = ((output - highJump[i]) * (output - highJump[i])) / 2 + loss
        outputNode = np.array(outputNode)
        # 反向传播
        # print("隐藏层结点", hide)
        for i in range(0, 14):
            # 隐藏层与输出层之间权值阈值更新
            wOutputLoss = []
            for j in range(0, 6):
                wOutputLoss.append((outputNode[i] - highJump[i]) *
                                   outputNode[i] * (1 - outputNode[i])
                                   * hide[j])
            wOutputLoss = np.array(wOutputLoss)
            # print("wOutputLoss", wOutputLoss)
            bOutputLoss = []
            for j in range(0, 6):
                bOutputLoss.append((outputNode[i] - highJump[i]) *
                                   outputNode[i] * (1 - outputNode[i]))
            bOutputLoss = np.array(bOutputLoss)
            # print("bOutputLoss", bOutputLoss)
            for j in range(0, 6):
                wOutput[j] = wOutput[j] - 0.1 * wOutputLoss[j]
                bOutput[j] = bOutput[j] - 0.1 * bOutputLoss[j]
            # print("隐藏层与输出层更新后权值和阈值", wOutput, bOutput)
            # 输入层与隐藏层之间权值更新
            wInputLoss = np.ones((6, 8)) * 0
            for j in range(0, 6):
                for k in range(0, 8):
                    wInputLoss[j][k] = ((outputNode[i] - highJump[i]) *
                                        outputNode[i] *
                                        (1 - outputNode[i]) * wOutput[j]
                                        * hide[j] * (1 - hide[j]) * data[i][k])
            wInputLoss = np.array(wInputLoss)
            # print("wIutputLoss", wInputLoss)
            bInputLoss = np.ones((6, 8)) * 0
            for j in range(0, 6):
                for k in range(0, 8):
                    bInputLoss[j][k] = ((outputNode[i] - highJump[i]) *
                                        outputNode[i] * (1 - outputNode[i]) *
                                        wOutput[j] * hide[j] * (1 - hide[j]))
            bInputLoss = np.array(bInputLoss)
            #print("bIutputLoss", bInputLoss)
            for j in range(0, 6):
                for k in range(0, 8):
                    wInput[j][k] = wInput[j][k] - 0.1 * wInputLoss[j][k]
                    bInput[j][k] = bInput[j][k] - 0.1 * bInputLoss[j][k]
            #print("输入层与隐藏层之间更新后的权值和阈值", wInput, bInput)
        print("输出", output)
        print("学习前的loss", loss)
        loss = 0
        for i in range(0, 14):
            # 正向传播
            # 计算隐藏层节点输入
            hide = []
            for j in range(0, 6):
                hideNode = 0
                for k in range(0, 8):
                    hideNode = data[i, k] * wInput[j, k] + \
                               bInput[j, k] + hideNode
                hideNode = tanh(hideNode)  # 激活函数
                hide.append(hideNode)
            hide = np.array(hide)
            output = 0
            for j in range(0, 6):
                output = hide[j] * wOutput[j] + bOutput[j] + output
            output = tanh(output)
            loss = ((output - highJump[i]) * (output - highJump[i])) / 2 + loss
        print("输出", output)
        print("学习后的loss", loss)

    # 预测
    hide = []
    for j in range(0, 6):
        hideNode = 0
        for k in range(0, 8):
            hideNode = data15[k] * wInput[j, k] + \
                       bInput[j, k] + hideNode
            hideNode = tanh(hideNode)  # 激活函数
        hide.append(hideNode)
    hide = np.array(hide)
    output = 0
    for j in range(0, 6):
        output = hide[j] * wOutput[j] + bOutput[j] + output
    output = tanh(output)
    print(output)
    print(loss)
    print(count)


if __name__ == '__main__':
    main()

上述代码和之前的bp神经网络有着相同的层，每层有相同的神经元，仅对loss结果和激活函数进行了修改。

上述代码在一开始的运行结果如图:
 

结果多次学习后的代码如图:

可见学习了506次之后，学习后的损失值反而更大了，这里可能是由于过拟合之类的问题造成的，

不过可以初步判定该段代码相对于sigmoid函数不是很适合tanh激活函数，也可以看到在该段代码中将tanh用于输出层的效果不如sigmoid。

  • relu激活函数

relu函数：

relu函数图像：

relu函数的使用情况:

1.二分类问题中除了输出层外全部用relu

2.在不确定的情况下一般优先考虑relu

3.relu中负数会直接变为0

4.遇到死的神经元也会使用relu

relu函数的特点：

整流线性单元（Rectified linear unit，ReLU）是现代神经网络中最常用的激活函数，大多数前馈神经网络默认使用的激活函数。

优点：

1.使用ReLU的SGD算法的收敛速度比 sigmoid 和 tanh 快。

2. 在x>0区域上，不会出现梯度饱和、梯度消失的问题。

3. 计算复杂度低，不需要进行指数运算，只要一个阈值就可以得到激活值。

缺点：

ReLU的输出不是0均值（将每个像素的值减去训练集上所有像素值的平均值，比如已计算得所有像素点的平均值为128，所以减去128后，现在的像素值域即为[-128,127]，即满足均值为零。）的。

relu函数的例子笔者就不再算一次了，基本算法思路和代码和上文一样。

小豚鼠lullaby
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一些比较常用的激活函数介绍
qq_43183663的博客
03-26 1297
一些比较常用的激活函数介绍一、Sigmoid函数二、tanh函数三、 ReLu函数 一、Sigmoid函数 sigmoid函数也叫Logistic函数，用于隐层神经元输出，取值范围为(0,1)，它可以将一个实数映射到(0,1)的区间，可以用来做二分类。在特征相差比较复杂或是相差不是特别大时效果比较好。Sigmoid作为激活函数有以下优缺点： 优点：平滑，易于求导 缺点： （1）激活函数计算量大，反向传播求误差梯度时，求导涉及除法； （2）反向传播时，很容易就会出现梯度消失的情况，从而无法完成深层网络的训练。
深度学习入门~激活函数③
fatfairyyy的博客
04-16 735
神经网络的激活函数 双曲正切函数tanh(x) 之前我们使用的神经网络，一直选择sigmoid函数作为激活函数，但实际上，激活函数可以是任何函数。 使用双曲正切函数，它的表现比sigmoid函数更好。 tanh(x)函数公式： 函数曲线：介于(-1,1)，类似于sigmoid函数的平移版本。 使用tanh(x)的好处： ①函数图像过原点。（sigmoid函数的图像不过原点） ②收敛速度快于sigmoid函数。 由于双曲正切函数介于(-1,1)之间，使用它作为激活函数好于sigmoid函数。因为使用它
函数知识点详解，带你从0到1写出自己的函数！！！
weixin_52134286的博客
08-16 560
内容介绍1 函数是什么？2 c语言中函数的分类2.1 库函数2.2 用户自定义函数3 函数的参数3.1 实际参数（实参）3.2 形式参数（形参）4 函数的调用4.1 传值调用4.2 传址调用5 函数的嵌套调用和链式访问5.1 嵌套调用5.2 链式访问6 函数的声明和定义6.1 函数声明6.2 函数定义 1 函数是什么？ 数学中我们常见到函数的概念。但是你了解C语言中的函数吗？维基百科中对函数的定义：子程序 在计算机科学中，子程序(Subroutine,procedure,function,routine
为什么CNN的激活函数使用relu,RNN的激活函数使用tanh？
qq_45689637的博客
04-17 645
为什么CNN的激活函数使用relu,RNN的激活函数使用tanh？
一文掌握ReLU激活函数：深度学习中不可或缺的神器
最新发布
weixin_42132035的博客
07-09 2648
ReLU，全称为修正线性单元(Rectified Linear Unit)，在深度学习领域中，是一种非常普遍且重要的激活函数，在众多神经网络模型中广泛应用。ReLU激活函数的实现非常简单，其数学表达式为： [ \text{ReLU}(x) = \max(0, x) ] 这意味着如果输入x为正，ReLU函数的输出就是x本身；如果输入x为负或者为0，ReLU函数的输出就是0。简单来说，ReLU函数就是一个线性和非线性特征的融合。
深度学习之常用激活函数
AndyJ的学习之旅
09-09 1760
引言 激活函数的目标是，将神经网络非线性化。激活函数是连续的且可导的。 连续的：当输入值发生较小的改变时，输出值也发生较小的改变； 可导的：在定义域中，每一处都是存在导数； 常见的激活函数：sigmoid，tanh，relu。 sigmoid sigmoid是平滑的阶梯函数，可导。sigmoid可以将任何值转换为0~1概率，用于二分类。 当使用sigmoid作为激活函数时，随着神经网络隐含层（hidden layer）层数的增加，训练误差反而加大。表现为： 靠近输出层的隐含层梯度较大，参数更新速度快，很
激活函数(sigmoid、tanh、ReLU、softmax)
tcn760的博客
04-07 7万+
文章目录1.1、sigmoid函数1.2、tanh函数1.3、ReLU函数1.4、softmax函数 激活函数在神经网络中的作用有很多，主要作用是给神经网络提供非线性建模能力。如果没有激活函数，那么再多层的神经网络也只能处理线性可分问题。常用的激活函数有sigmoid、tanh、relu、softmax等。 1.1、sigmoid函数 sigmoid函数将输入变换为(0,1)上的输出。它将范围(-inf,inf)中的任意输入压缩到区间(0,1)中的某个值： sigmoid(x)=11+exp(−x)sigm
MATLAB——sigmoid传递函数
一抹烟霞的博客
03-13 1930
一、log——sigmoid函数 二、tan——sigmoid函数
神经网络常用的三大激活函数sigmoid函数、tanh函数、relu函数对比讲解
梁先森的博客
10-17 1万+
在我们学习神经网络的时候经常要用到激活函数，但是我们对于为什么要使用这一个，它们之间的区别和优缺点各是什么不太了解。下面，我们来详细说一说这三个激活函数。 - sigmoid函数 sigmoid函数也叫Logistic函数，用于隐层神经元输出，取值范围为(0,1)，它可以将一个实数映射到(0,1)的区间，可以用来做二分类。在特征相差比较复杂或是相差不是特别大时效果比较好。 其函数表达式是： ...
深度学习之激活函数的介绍和比较：sigmoid，tanh，relu，softmax
Yio_Eagle的博客
09-07 2123
本文参考自3个博客，整理合并而成。 1.https://blog.csdn.net/haxiongha/article/details/79404304 2.https://blog.csdn.net/u011684265/article/details/78039280 3.https://www.cnblogs.com/gezhuangzhuang/p/10583394.html 目录...
比较双曲正切tanh与sigmoid激活函数的性能差异
staple
04-23 3159
制作一个二分类网络分类minst 0和3 (0,3)-n*m*2-(1,0)(0,1) 激活函数分别使用tanh和sigmoid，用交叉对比固定收敛标准多次测量取平均值的办法比较两个激活函数到底有什么差异。 数据1：tanh 每个收敛标准收敛199次，共25*199次 tanh ...
激活函数sigmoid和tanh
qq_38883271的博客
03-05 1041
1.sigmoid函数也称为S型函数，该函数将变量全部映射到(0,1)区间。函数表达式如下所示： import numpy as np import matplotlib.pyplot as plt def sigmoid(x): return 1 / (1+np.exp(-x)) x = np.arange(-10,10,0.01) y = sigmoid(x) plt.plot(...
sigmod函数tanh函数ReLU函数
fendoubasaonian的专栏
10-30 4万+
一. sigmod(x)函数sigmod函数的数学公式为: Θ(x)=11+e−x \Theta(x)=\frac {1}{1+e^{-x} } 函数取值范围(0,1),函数图像下图所示:二. tanh(x) 函数tanh(x)函数的数学公式为：tanh(x)=sinh(x)cosh(x)tanh(x) = \frac{sinh(x)}{cosh(x)} 函数取值范围(-1,1),函数图像
信用卡交易数据异常检测
weixin_44458771的博客
08-02 3688
creditcard.csv信用卡交易数据异常检测
sigmoid
lengzhao的专栏
04-11 2428
sigmoid 函数sigmoid函数是一个良好的阈值函数 特点： 连续，光滑 严格单调 关于(0,0.5)中心对称 对阈值函数有一个良好的近似 原函数：f(x) = 1/[1+e^(-x)] 其导数：f’(x)=f(x)*[1-f(x)] 选择使用Sigmoid的原因以下内容转自知乎 sigmoid这个函数实质上是以分类为目的出现的。 传统的回归直接给出具体值，而当某些情况我们
机器学习中的数学——激活函数（一）：Sigmoid函数
热门推荐
冯·诺依曼
10-05 15万+
Sigmoid函数是一个在生物学中常见的S型函数，也称为S型生长曲线。在深度学习中，由于其单增以及反函数单增等性质，Sigmoid函数常被用作神经网络的激活函数，将变量映射到[0,1][0, 1][0,1]之间。 S(x)=11+e−xS(x)=\frac{1}{1+e^{-x}}S(x)=1+e−x1​ Sigmoid函数的导数可以用其自身表示： S′(x)=e−x(1+e−x)2=S(x)(1−S(x))S'(x)=\frac{e^{-x}}{(1+e^{-x})^2}=S(x)(1-S(x))S′(x
机器学习-sigmoid函数和relu函数-个人解读
weixin_43327597的博客
07-10 4360
而且根据输入激活函数随机性的原理我们可以知道，经过这个激活函数处理，有一般的概率输出为0，由反向传播的原理知道，经过激活函数输出为0，那么这激活函数在这次样本输入中其梯度就为0，也就是不会被更新，且该神经元的输出也不会对最终结果再有影响。第二，就是relu函数的真正精髓，每次训练会随机的让让很大一部分神经元失灵，只更新部分神经元，每次更新的部分神经元是随机的，在这种情况下，每次被更新的神经元组合是很复杂的，相同性很低，那么就可以有效的让神经元独立学习，孤军奋战，不那么被其他神经元影响，做出自己的有利贡献。
如何确定分类的阈值，如何确定哪个模型好呢
mjiansun的专栏
09-03 7680
当时使用sigmoid时，如果确定分类的阈值呢？ 一般我们喜欢使用0.5这个默认的值。但是如果有更好的阈值使得结果更好，那该如何处理呢。。。 可以使用ROC，如下例子所示，排好序的阈值以对应的10个阈值进行划分，得到对应的统计值。 根据你能接受的假阳性率FPR和召回率TPR来确定对应的点位，再根据点位来查找该点位对应的阈值。 ...
sigmoid函数溢出处理
Focus
07-27 4837
简介 在实现logistic regression算法的时候，发现sigmoid函数（下方函数）在输入的数是较小负数时，会出现溢出的情况。 σ(z)=11+e−z\sigma(z)=\frac{1}{1+e^{-z}}σ(z)=1+e−z1​ 解决方法 通过对正数和非正数分别计算来避免溢出。 def sigmoid(Z): # 解决溢出问题 # 把大于0和小于0的元素分别处理 # 原来的sigmoid函数是 1/(1+np.exp(-Z)) # 当Z是比较小的负数时会出现上溢
Sigmoid 函数、Tanh 和 ReLU 函数
08-05
### 回答1： Sigmoid 函数是一种非线性函数，它的输出值介于 0 和 1 之间，可以用来激活神经元。Tanh 函数也是一种非线性函数，其输出值也介于 -1 和 1 之间，可以用来激活神经元。ReLU 函数是一种常用的非线性函数，它的输出值是输入值的绝对值，可以用来激活神经元。 ### 回答2： Sigmoid函数、Tanh函数和ReLU函数都是常用的激活函数，常用于神经网络模型中。 1. Sigmoid函数是一个非线性的函数，其数学定义为：f(z) = 1 / (1 + exp(-z))。它有一个S形的曲线，取值范围在0到1之间。Sigmoid函数的主要特点是将输入的连续实数转化为概率形式的输出，常用于二分类问题中，可以将输出映射到0和1之间，表示了某个事件发生的概率。然而，由于其容易出现梯度消失和梯度爆炸的问题，当网络层数较多时，Sigmoid函数在反向传播中可能导致梯度无法有效地传播。 2. Tanh函数是双曲线正切函数，其数学定义为：f(z) = (exp(z) - exp(-z)) / (exp(z) + exp(-z))。类似于Sigmoid函数，Tanh函数也是非线性函数，但其输出范围在-1到1之间。相比于Sigmoid函数，Tanh函数在原点附近有一个均值为0的对称点，具有更好的中心化特性，可以减小梯度爆炸的问题。然而，Tanh函数仍然存在梯度消失的问题。 3. ReLU函数是修正线性单元函数，其数学定义为：f(z) = max(0, z)。ReLU函数在输入大于零时输出等于输入，小于零时输出为零。ReLU函数具有简单的计算形式，并且在训练过程中具有更快的收敛速度。由于ReLU函数的输出非负，不存在梯度消失的问题。然而，ReLU函数在输入为负时会失活，导致相应神经元的权重和梯度无法进行更新。为解决这个问题，出现了ReLU的变种，如Leaky ReLU、PReLU等。 总结来说，Sigmoid函数和Tanh函数在某些场景下仍然有一定的应用，但在深度神经网络中，ReLU函数更受欢迎，因为它可以在一定程度上减轻梯度消失和梯度爆炸问题，并提供更快的训练速度。 ### 回答3： Sigmoid函数是一种常用的激活函数，它将输入的实数映射到一个介于0和1之间的概率值。其公式为： \[f(x) = \frac{1}{1 + e^{-x}}\] 该函数的特点是输出在区间(0,1)之间，对于大部分实数输入都能产生有效的梯度，但在输入接近两端的时候，梯度会变得很小。因此，Sigmoid函数在深度神经网络的训练过程中可能会出现梯度消失的问题。 Tanh函数是双曲正切函数，它将输入的实数映射到一个介于-1和1之间的值。其公式为： \[f(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}\] 与Sigmoid函数相比，Tanh函数的输出区间更大，梯度也更大。它相对于原点对称，并且输入为负数时，输出接近-1，输入为正数时，输出接近1。因此，Tanh函数适用于输出介于-1和1之间的情况，但仍然存在梯度消失的问题。 ReLU函数是修正线性单元函数，它将输入的实数映射为输入本身或者0。其公式为： \[f(x) = max(0, x)\] ReLU函数当输入为正数时，输出等于输入；当输入为负数时，输出为0。相较于Sigmoid函数和Tanh函数，ReLU函数计算速度更快，并且不存在梯度消失的问题。然而，ReLU函数也存在一个缺点，就是在输入为负数时，梯度为0，从而导致对应的权重无法更新。为了解决这个问题，一些改进的版本如Leaky ReLU和Parametric ReLU被提出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值