神经网络激活函数（二）：Tanh激活函数

原创 已于 2025-11-22 13:41:45 修改 · 1.3k 阅读 · 23 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2025-11-18 08:57:11 首次发布

目录

1. 基本概念

1.1 什么是Tanh激活函数？

1.2 Tanh的数学定义

2. 原理详解

2.1 数学特性分析

函数特性：

导数计算：

2.2 Tanh与Sigmoid的关系

2.3 可视化理解

3. Tanh的优势与局限性

3.1 主要优势

3.2 主要局限性

3.3 梯度特性分析

4. 各种激活函数对比

4.1 主要激活函数全面对比

4.2 选择指南决策树

4.3 性能对比分析

训练速度排名：

收敛稳定性排名：

5. 应用场景

5.1 推荐使用场景

5.2 不推荐使用场景

5.3 与其他技术的配合

与批量归一化的配合：

与权重初始化的配合：

6. TensorFlow代码实现

6.1 基础Tanh实现

6.2 使用Keras的高级实现

6.3 完整训练示例

6.4 激活函数对比实验

7. 使用技巧与最佳实践

7.1 Tanh优化技巧

7.2 超参数调优指南

学习率选择：

批量大小：

网络深度：

7.3 问题诊断与解决

7.4 性能监控指标

训练过程监控：

收敛判断：

8. 高级应用与变种

8.1 Tanh的变种改进

8.2 与其他技术的集成

与注意力机制配合：

在残差网络中使用：

总结

关键要点：

选择建议：

1. 基本概念

1.1 什么是Tanh激活函数？

双曲正切函数（Tanh） 是一种非线性激活函数，将输入值压缩到(-1,1)的范围内。它是深度学习中最常用的激活函数之一，特别在循环神经网络和某些类型的卷积神经网络中表现优异。

1.2 Tanh的数学定义

Tanh函数的数学表达式为：

tanh(x) = (e^x - e^(-x)) / (e^x + e^(-x))

或者等价表示为：

tanh(x) = 2 × sigmoid(2x) - 1

2. 原理详解

2.1 数学特性分析

函数特性：

  • 输出范围：(-1, 1)

  • 零中心性：函数关于原点对称

  • 单调性：严格递增函数

  • 饱和性：在|x|较大时趋于±1

导数计算：
tanh'(x) = 1 - tanh²(x)

导数的取值范围为(0, 1]，在x=0时取得最大值1。

2.2 Tanh与Sigmoid的关系

转换关系：

tanh(x) = 2σ(2x) - 1

其中σ表示Sigmoid函数。

关键改进：

  • Sigmoid输出范围：(0, 1)

  • Tanh输出范围：(-1, 1) ← 零中心优势

2.3 可视化理解

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

def plot_tanh_comparison():
    """绘制Tanh函数及其导数"""
    x = np.linspace(-4, 4, 1000)
    tanh = np.tanh(x)
    tanh_derivative = 1 - np.tanh(x)**2
    
    plt.figure(figsize=(15, 5))
    
    # Tanh函数
    plt.subplot(1, 3, 1)
    plt.plot(x, tanh, 'b-', linewidth=3, label='Tanh')
    plt.title('Tanh激活函数', fontsize=14, fontweight='bold')
    plt.xlabel('x', fontsize=12)
    plt.ylabel('tanh(x)', fontsize=12)
    plt.grid(True, alpha=0.3)
    plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
    plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
    plt.legend()
    
    # Tanh导数
    plt.subplot(1, 3, 2)
    plt.plot(x, tanh_derivative, 'r-', linewidth=3, label='Tanh导数')
    plt.title('Tanh导数', fontsize=14, fontweight='bold')
    plt.xlabel('x', fontsize=12)
    plt.ylabel("tanh'(x)", fontsize=12)
    plt.grid(True, alpha=0.3)
    plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
    plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
    plt.legend()
    
    # 与Sigmoid对比
    plt.subplot(1, 3, 3)
    sigmoid = 1 / (1 + np.exp(-x))
    plt.plot(x, tanh, 'b-', linewidth=2, label='Tanh')
    plt.plot(x, sigmoid, 'g--', linewidth=2, label='Sigmoid')
    plt.title('Tanh vs Sigmoid', fontsize=14, fontweight='bold')
    plt.xlabel('x', fontsize=12)
    plt.ylabel('输出', fontsize=12)
    plt.grid(True, alpha=0.3)
    plt.legend()
    
    plt.tight_layout()
    plt.show()

plot_tanh_comparison()

运行代码生成下图：

3. Tanh的优势与局限性

3.1 主要优势

优势

说明

影响

零中心输出

输出范围(-1,1)，均值为0

改善梯度流动，加速收敛

可解释性强

负值表示抑制，正值表示激活

更好的生物学合理性

平滑可微

处处可导，导数连续

优化过程更稳定

饱和特性

对大输入值饱和

对异常值不敏感

3.2 主要局限性

局限性

说明

影响

梯度消失

在饱和区梯度接近0

深层网络训练困难

计算成本

涉及指数运算

比ReLU计算量大

非稀疏激活

大多数神经元被激活

计算效率低于ReLU

3.3 梯度特性分析

def analyze_gradient_behavior():
    """分析Tanh梯度特性"""
    x = np.linspace(-3, 3, 1000)
    
    # 计算不同点的梯度
    gradients = 1 - np.tanh(x)**2
    
    plt.figure(figsize=(10, 6))
    
    # 梯度分布
    plt.subplot(1, 2, 1)
    plt.plot(x, gradients, 'purple', linewidth=2)
    plt.fill_between(x, 0, gradients, alpha=0.3, color='purple')
    plt.title('Tanh梯度分布', fontsize=14)
    plt.xlabel('输入值 x')
    plt.ylabel('梯度值')
    plt.grid(True, alpha=0.3)
    
    # 梯度保留比例
    plt.subplot(1, 2, 2)
    gradient_retention = gradients * 100  # 百分比
    plt.plot(x, gradient_retention, 'orange', linewidth=2)
    plt.axhline(y=50, color='red', linestyle='--', alpha=0.7, label='50%梯度线')
    plt.title('梯度保留比例(%)', fontsize=14)
    plt.xlabel('输入值 x')
    plt.ylabel('梯度保留比例(%)')
    plt.grid(True, alpha=0.3)
    plt.legend()
    
    plt.tight_layout()
    plt.show()
    
    # 打印关键数据点
    critical_points = [-2, -1, 0, 1, 2]
    print("关键点的梯度值:")
    for point in critical_points:
        grad = 1 - np.tanh(point)**2
        print(f"x={point}: tanh(x)={np.tanh(point):.4f}, 梯度={grad:.4f}")

analyze_gradient_behavior()

4. 各种激活函数对比

4.1 主要激活函数全面对比

特性

Tanh

Sigmoid

ReLU

Leaky ReLU

ELU

输出范围

(-1, 1)

(0, 1)

[0, ∞)

(-∞, ∞)

(-α, ∞)

零中心

✅

❌

❌

❌

✅

计算效率

中

低

高

高

中

梯度消失

严重

严重

缓解

缓解

缓解

死亡神经元

无

无

有

很少

无

饱和性

双向饱和

双向饱和

单向饱和

无饱和

负区饱和

适用场景

RNN, 浅层网络

输出层, 二分类

深层CNN, 默认选择

替代ReLU

深层网络

4.2 选择指南决策树

选择激活函数的决策流程：

需要概率输出？
├── 是 → 二分类？ → Sigmoid
│       └── 多分类？ → Softmax
└── 否 → 网络类型？
    ├── RNN/LSTM → Tanh 或 Sigmoid
    ├── 深层CNN → ReLU 或 Leaky ReLU
    ├── 自编码器 → Tanh 或 Sigmoid
    └── 默认选择 → ReLU

4.3 性能对比分析

训练速度排名：

  1. ReLU - 最快（计算简单，无饱和）

  2. Leaky ReLU - 很快（类似ReLU）

  3. Tanh - 中等（指数计算）

  4. ELU - 中等（指数计算）

  5. Sigmoid - 最慢（梯度消失严重）

收敛稳定性排名：

  1. Tanh - 优秀（零中心，平滑）

  2. ELU - 很好（负区处理优秀）

  3. Leaky ReLU - 好（避免死亡神经元）

  4. Sigmoid - 中等（梯度消失）

  5. ReLU - 较差（死亡神经元问题）

5. 应用场景

5.1 推荐使用场景

应用场景

推荐理由

示例网络

注意事项

循环神经网络

零中心特性改善梯度流动

LSTM, GRU

配合梯度裁剪

自编码器

输出范围匹配输入归一化

去噪自编码器

输入需归一化到(-1,1)

生成对抗网络

生成器输出需要负值

DCGAN

配合BatchNorm

浅层网络

避免梯度消失问题

简单分类器

网络深度<5层

时间序列预测

对正负变化敏感

序列模型

输入标准化

5.2 不推荐使用场景

场景

不推荐理由

替代方案

深层前馈网络

梯度消失严重

ReLU, Leaky ReLU

实时推理系统

计算成本较高

ReLU

大规模图像分类

收敛速度慢

ReLU系列

需要稀疏激活

Tanh激活密度高

ReLU

5.3 与其他技术的配合

与批量归一化的配合：
推荐组合：Tanh + BatchNorm
效果：稳定训练，加速收敛
原理：BatchNorm确保输入分布稳定，缓解Tanh饱和问题
与权重初始化的配合：
推荐初始化：Xavier/Glorot初始化
公式：W ~ Uniform(-√(6/(n_in+n_out)), √(6/(n_in+n_out)))
原理：保持输入输出的方差稳定

6. TensorFlow代码实现

6.1 基础Tanh实现

import tensorflow as tf
import numpy as np

class TanhNetwork:
    """使用Tanh激活函数的神经网络"""
    
    def __init__(self, layer_sizes, learning_rate=0.001):
        self.layer_sizes = layer_sizes
        self.learning_rate = learning_rate
        
        # 使用Xavier初始化配合Tanh
        initializer = tf.keras.initializers.GlorotUniform()
        

        self.weights = [ ]


        self.biases = [ ]

        
        for i in range(len(layer_sizes) - 1):
            w = tf.Variable(
                initializer(shape=[layer_sizes[i], layer_sizes[i+1]]),
                name=f"W_{i}"
            )
            b = tf.Variable(
                tf.zeros([layer_sizes[i+1]]),
                name=f"b_{i}"
            )
            self.weights.append(w)
            self.biases.append(b)
        
        self.optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
    
    def forward(self, x, training=True):
        """前向传播使用Tanh激活"""
        a = x
        
        # 隐藏层使用Tanh
        for i, (w, b) in enumerate(zip(self.weights[:-1], self.biases[:-1])):
            z = tf.matmul(a, w) + b
            a = tf.nn.tanh(z)  # Tanh激活
        
        # 输出层使用Softmax（分类任务）
        z_output = tf.matmul(a, self.weights[-1]) + self.biases[-1]
        output = tf.nn.softmax(z_output)
        
        return output
    
    def compute_loss(self, y_true, y_pred):
        """计算交叉熵损失"""
        return tf.reduce_mean(
            tf.keras.losses.sparse_categorical_crossentropy(y_true, y_pred)
        )
    
    def train_step(self, x, y):
        """训练步骤"""
        with tf.GradientTape() as tape:
            predictions = self.forward(x)
            loss = self.compute_loss(y, predictions)
        
        gradients = tape.gradient(loss, self.weights + self.biases)
        self.optimizer.apply_gradients(zip(gradients, self.weights + self.biases))
        
        return loss
    
    def accuracy(self, y_true, y_pred):
        """计算准确率"""
        predicted_labels = tf.argmax(y_pred, axis=1)
        correct_predictions = tf.equal(y_true, predicted_labels)
        return tf.reduce_mean(tf.cast(correct_predictions, tf.float32))

6.2 使用Keras的高级实现

def create_tanh_models():
    """创建不同配置的Tanh网络"""
    
    models = {}
    
    # 基础Tanh网络
    models['basic_tanh'] = tf.keras.Sequential([
        tf.keras.layers.Dense(128, activation='tanh', input_shape=(784,),
                             kernel_initializer='glorot_uniform'),
        tf.keras.layers.Dense(64, activation='tanh',
                             kernel_initializer='glorot_uniform'),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    
    # Tanh + 批量归一化
    models['tanh_bn'] = tf.keras.Sequential([
        tf.keras.layers.Dense(128, input_shape=(784,)),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.Activation('tanh'),
        
        tf.keras.layers.Dense(64),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.Activation('tanh'),
        
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    
    # Tanh + Dropout正则化
    models['tanh_dropout'] = tf.keras.Sequential([
        tf.keras.layers.Dense(128, activation='tanh', input_shape=(784,)),
        tf.keras.layers.Dropout(0.3),
        tf.keras.layers.Dense(64, activation='tanh'),
        tf.keras.layers.Dropout(0.3),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    
    return models

def compile_and_train_models(models, x_train, y_train, x_val, y_val, epochs=50):
    """编译并训练模型"""
    
    histories = {}
    
    for name, model in models.items():
        print(f"\n训练模型: {name}")
        
        # 编译模型
        model.compile(
            optimizer='adam',
            loss='sparse_categorical_crossentropy',
            metrics=['accuracy']
        )
        
        # 训练模型
        history = model.fit(
            x_train, y_train,
            batch_size=32,
            epochs=epochs,
            validation_data=(x_val, y_val),
            verbose=1
        )
        
        histories[name] = history
    
    return histories

6.3 完整训练示例

def run_tanh_experiment():
    """运行Tanh激活函数的完整实验"""
    
    # 加载数据
    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
    
    # 数据预处理 - 归一化到(-1,1)范围以匹配Tanh输出
    x_train = x_train.reshape(-1, 784).astype('float32') / 255.0 * 2 - 1
    x_test = x_test.reshape(-1, 784).astype('float32') / 255.0 * 2 - 1
    
    # 分割验证集
    x_train, x_val = x_train[:50000], x_train[50000:]
    y_train, y_val = y_train[:50000], y_train[50000:]
    
    print(f"训练集: {x_train.shape}, 验证集: {x_val.shape}, 测试集: {x_test.shape}")
    
    # 创建不同配置的Tanh模型
    models = create_tanh_models()
    
    # 显示模型结构
    for name, model in models.items():
        print(f"\n{name} 结构:")
        model.summary()
    
    # 训练模型
    histories = compile_and_train_models(
        models, x_train, y_train, x_val, y_val, epochs=30
    )
    
    # 评估模型
    results = {}
    for name, model in models.items():
        test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
        results[name] = {
            'test_accuracy': test_accuracy,
            'test_loss': test_loss,
            'history': histories[name]
        }
        print(f"{name} - 测试准确率: {test_accuracy:.4f}")
    
    return models, results

# 运行实验
models, results = run_tanh_experiment()

6.4 激活函数对比实验

def activation_function_comparison():
    """比较不同激活函数的性能"""
    
    # 加载数据
    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
    x_train = x_train.reshape(-1, 784).astype('float32') / 255.0
    x_test = x_test.reshape(-1, 784).astype('float32') / 255.0
    
    # 定义不同的激活函数
    activations = {
        'Tanh': 'tanh',
        'ReLU': 'relu',
        'Sigmoid': 'sigmoid',
        'LeakyReLU': tf.keras.layers.LeakyReLU(alpha=0.01),
        'ELU': 'elu'
    }
    
    comparison_results = {}
    
    for act_name, activation in activations.items():
        print(f"\n训练使用 {act_name} 的模型...")
        
        # 创建模型
        if act_name == 'LeakyReLU':
            model = tf.keras.Sequential([
                tf.keras.layers.Dense(128, input_shape=(784,)),
                activation,
                tf.keras.layers.Dense(64),
                activation,
                tf.keras.layers.Dense(10, activation='softmax')
            ])
        else:
            model = tf.keras.Sequential([
                tf.keras.layers.Dense(128, activation=activation, input_shape=(784,)),
                tf.keras.layers.Dense(64, activation=activation),
                tf.keras.layers.Dense(10, activation='softmax')
            ])
        
        # 编译模型
        model.compile(
            optimizer='adam',
            loss='sparse_categorical_crossentropy',
            metrics=['accuracy']
        )
        
        # 训练模型（使用少量epochs快速比较）
        history = model.fit(
            x_train, y_train,
            batch_size=32,
            epochs=15,
            validation_split=0.2,
            verbose=0
        )
        
        # 评估模型
        test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
        
        comparison_results[act_name] = {
            'test_accuracy': test_accuracy,
            'test_loss': test_loss,
            'history': history,
            'model': model
        }
        
        print(f"{act_name} - 测试准确率: {test_accuracy:.4f}")
    
    return comparison_results

# 运行对比实验
comparison_results = activation_function_comparison()

7. 使用技巧与最佳实践

7.1 Tanh优化技巧

技巧

说明

实现方法

合适的初始化

使用Xavier初始化

kernel_initializer='glorot_uniform'

输入归一化

将输入缩放到(-1,1)

(x / 255.0) * 2 - 1

配合BatchNorm

稳定输入分布

BatchNormalization() + Tanh()

学习率调整

使用较小的学习率

learning_rate=0.001

梯度裁剪

防止梯度爆炸

tf.clip_by_global_norm(gradients, 5.0)

7.2 超参数调优指南

学习率选择：
Tanh推荐学习率范围：0.0001 - 0.001
调整策略：从小开始，观察收敛情况
批量大小：
推荐范围：32 - 128
建议：配合BatchNorm使用较大批量
网络深度：
Tanh适用深度：2-5层
深层网络建议：使用残差连接或切换到ReLU

7.3 问题诊断与解决

问题现象

可能原因

解决方案

训练损失不下降

梯度消失、学习率太小

使用BatchNorm、增大学习率

损失震荡

学习率太大

减小学习率、使用学习率调度

过拟合

模型复杂、数据不足

增加Dropout、L2正则化

收敛速度慢

饱和神经元过多

检查输入分布、使用BatchNorm

7.4 性能监控指标

训练过程监控：

  • 梯度范数：应在合理范围内(10⁻⁶ 到 10²)

  • 激活值分布：应在(-1,1)范围内均匀分布

  • 梯度分布：检查是否有多数梯度接近0

收敛判断：

  • 训练损失：平稳下降至稳定值

  • 验证准确率：达到稳定且与训练准确率差距小

  • 梯度变化：梯度范数稳定在较小值

8. 高级应用与变种

8.1 Tanh的变种改进

变种

公式

改进点

适用场景

Hard Tanh

max(-1, min(1, x))

计算简单、稀疏激活

计算受限环境

TanhShrink

x - tanh(x)

零中心、缓解饱和

回归任务

Scaled Tanh

α × tanh(βx)

可调节饱和点

特定数据分布

8.2 与其他技术的集成

与注意力机制配合：
在Transformer的FFN中，Tanh可作为激活函数：
FFN(x) = W₂ × Tanh(W₁x + b₁) + b₂
在残差网络中使用：
残差块：y = x + F(x)
其中F(x) = W₂ × Tanh(W₁x + b₁) + b₂
注意：需要合适的初始化保持方差

总结

Tanh激活函数因其零中心特性和平滑的梯度，在特定场景下仍然是优秀的选择。通过合理的使用技巧和最佳实践，可以充分发挥其优势：

关键要点：

  1. 优势场景：RNN、自编码器、需要零中心输出的任务

  2. 核心优势：零中心输出改善梯度流动

  3. 主要局限：梯度消失问题限制在深层网络的应用

  4. 最佳实践：配合Xavier初始化、BatchNorm、合适的输入归一化

选择建议：

  • ✅ 推荐使用：循环网络、浅层网络、生成模型

  • ⚠️ 谨慎使用：深层前馈网络、实时推理系统

  • ❌ 避免使用：需要稀疏激活、计算资源受限的场景

Tanh在深度学习发展历程中扮演了重要角色，虽然在新架构中逐渐被ReLU系列取代，但在特定领域仍然具有不可替代的价值。理解其特性和适用场景，有助于在合适的任务中做出最佳的技术选择。

标签
#人工智能 #tensorflow #神经网络 #python
limenga102
关注
常用的激活函数（Sigmoid、Tanh、ReLU等）
Billie使劲学的博客
06-29 2万+
目录一、激活函数定义二、梯度消失与梯度爆炸 1.什么是梯度消失与梯度爆炸2.梯度消失的根本原因3.如何解决梯度消失与梯度爆炸问题 三、常用激活函数1.Sigmoid2.Tanh3.ReLU4.Leaky ReLU5.ELU6.softmax7.Swish 激活函数 (Activation functions) 对于人工神经网络模型去学习、理解非常复杂和非线性的函数来说具有十分重要的作用。它们将非线性特性引入到神经网络中。在下图中，输入的 inputs 通过加权，求和后，还被作用了一个函数f，这
卷积神经网络中的激活函数sigmoid、tanh、relu
chaiky的博客
05-08 1万+
目录 1、什么是激活函数？ 2、为什么要在卷积层后面添加激活函数? 3、激活函数的性质 3.1 sigmoid 激活函数 3.2 tanh 激活函数 3.3 ReLU 激活函数 4、如何选择激活函数？ 5、神经网络中的隐藏层是什么？ 1、什么是激活函数？ 一个神经元会同时接收多个信号，然后将这些信号乘以一定权重求和，再用函数处理后再输出新的信号。对神经元的输入进行处理，以获得输出的函数称为激活函数。 2、为什么要在卷积层后面添加激活函数? 如果只有线性变换，那无论多少层神经元，.
【NLP 14、激活函数 ② tanh激活函数】
m0_73983707的博客
12-11 1896
tanh是双曲正切函数（Hyperbolic Tangent），数学表达式为其函数图像是一个S型曲线，以原点 (0，0) 为中心对称，定义域为(-∞，+∞)，值域是( - 1,1)。
激活函数Tanh
August-us的博客
03-18 10万+
激活函数Tanh系列文章：   Tanh的诞生比Sigmoid晚一些，sigmoid函数我们提到过有一个缺点就是输出不以0为中心，使得收敛变慢的问题。而Tanh则就是解决了这个问题。Tanh就是双曲正切函数。等于双曲余弦除双曲正弦。函数表达式和图像见下图。这个函数是一个奇函数。   对tanh函数求导需要一定的数学基础，这里直接给出结果。tanh′(x)=1−tanh2(x)tanh'(x)=...
深度学习之激活函数——Tanh
m0_61787307的博客
05-14 7254
双曲正切1函数(tanh)，其图像与sigmoid函数十分相近，相当于sigmoid函数的放大版。在实际的使用中，tanh函数要优先于sigmoid函数。
神经网络的激活函数（二）Sigmiod、Softmax和Tanh
深数研究院
11-18 1269
本文我们介绍三个古早的激活函数，虽然古老，但是在神经网络中仍然有着广泛的应用，尤其是Softmax作为输出层，仍然是统治地位.
【深度学习实验】前馈神经网络（二）：使用PyTorch实现不同激活函数（logistic、tanh、relu、leaky_relu）
天地玄黄 魑魅魍魉 风花雪月 商角徵羽
09-19 1303
本文介绍了使用PyTorch实现不同激活函数（logistic、tanh、relu、leaky_relu）
神经网络中激活函数的总结
科技匠心的博客
03-05 973
激活函数出现的原因 1、遇到线性不可分的数据。神经网络也找不到一条合适的直线。 2、如何解决 尝试单层感知机。 尝试多层感知机 化简后发现仍然是一个线性分类器。 3、激活函数的作用 在隐藏层和输出层之间加入一个激活函数，sigmoid。 多层感知器 激活函数就是在神经元上加一个壳，为神经元带来非线性因素，提升模型的表达能力。第一步计算线性变化，第二步计算非线性变换。 激活函数大...
tensorflow中常用的激活函数
修炼之路
08-19 2万+
激活函数(activation function)运行时激活神经网络中某一部分神经元，将激活神经元的信息输入到下一层神经网络中。神经网络之所以能处理非线性问题，这归功于激活函数的非线性表达能力。激活函数需要满足数据的输入和输出都是可微的，因为在进行反向传播的时候，需要对激活函数求导。 在TensorFlow中也内置了许多的激活函数，安装好TensorFlow之后可以在tensorflow--&g...
深度学习——最常见的三种激活函数
hei653779919的博客
02-06 3983
深度学习——最常见的三种激活函数 1 tanh激活函数 1.1 函数原型 tanh(x)=ex−e−xex+e−xtanh(x) = \frac{e^x-e^{-x}}{e^x+e^{-x}}tanh(x)=ex+e−xex−e−x​ 1.2 函数图像 1.3 函数导数 tanh′(x)=1−tanh2(x)tanh'(x) = 1 - tanh^2(x)tanh′(x)=1−tanh2(x) ...
【深度学习基础】第七课：激活函数
最新发布
qq_34222839的博客
03-01 2085
目前为止，我们所用的激活函数都是sigmoid函数，但有时其他函数的效果要更好，本文将介绍其他常用的激活函数。
激活函数(sigmoid、tanh、ReLU、softmax)
热门推荐
tcn760的博客
04-07 11万+
文章目录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
三种激活函数——Sigmoid,Tanh, ReLU以及卷积感受野的计算
Le0v1n 的博客
05-03 7646
1. 三种激活函数——Sigmoid、Tanh、ReLU讲解以及图像 2. 感受野计算公式推理以及例题
激活函数（Relu，sigmoid，Tanh，softmax）详解
m0_53675977的博客
12-10 3万+
总结了常用的激活函数，如何在工程实践中合理选择激活函数。
tanh激活函数
zrh_CSDN的博客
07-31 1万+
tanh激活函数                         tanh也是一种非常常见的激活函数。与sigmoid相比，它的输出均值是0，使得其收敛速度要比sigmoid快，减少迭代次数。 然而，从图中可以看出，tanh和sigmoid一样具有软饱和性，从而造成梯度消失。 ...
Tanh激活函数详解
2401_86968005的博客
02-24 3001
tanh（双曲正切）激活函数是一种在神经网络中常用的非线性激活函数。它的主要作用是引入非线性因素，使得神经网络可以学习和模拟更复杂的函数关系。同时，tanh函数的输出范围在(-1, 1)之间，具有零均值特性，有助于模型的收敛。：(-1, 1)：关于原点对称的S型曲线tanhxexe−xex−e−x​。
激活函数（4）tanh函数
zfjBIT的专栏
06-12 1万+
tanh函数 双曲正切激活函数，函数解析式： tanh函数及其导数的几何图像如下图： tanh读作Hyperbolic Tangent，它解决了Sigmoid函数的不是zero-centered输出问题，然而，梯度消失（gra...
激活函数之tanh介绍及C++/PyTorch实现
网络资源是无限的
07-29 6181
深度神经网络中使用的激活函数有很多种，这里介绍下tanh。它的公式如下，截图来自于维基百科(https://en.wikipedia.org/wiki/Activation_function)： tanh又称双曲正切，它解决了sigmoid非零中心问题。tanh取值范围在(-1, 1)内，它也是非线性的。它也不能完全解决梯度消失问题。 C++实现如下： template<typename _Tp> int activation_function_t...
激活函数——tanh函数
Yinkle的博客
08-29 5098
tanhtanh是双曲函数中的一个，tanh()tanh()为双曲正切。在数学中，双曲正切“tanhtanh”是由基本双曲函数双曲正弦和双曲余弦推导而来。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值