Dense参数详解

Dense参数介绍

Dense调用命令：

class Dense(
 units, 
 activation=None, 
 use_bias=True,
 kernel_initializer='glorot_uniform',
 bias_initializer='zeros',
 kernel_regularizer=None,
 bias_regularizer=None,
 activity_regularizer=None,
 kernel_constraint=None, 
bias_constraint=None,
 **kwargs)

我们常用到的参数有

• units:设置该层节点数，也可以看成对下一层的输出。
• activation：激活函数，在这一层输出的时候是否需要激活函数
• use_bias：偏置，默认带有偏置。

其他参数的含义：

• kernel_initializer:权重初始化方法
• bias_initializer:偏置值初始化方法
• kernel_regularizer:权重规范化函数
• bias_regularizer:偏置值规范化方法
• activity_regularizer:输出的规范化方法
• kernel_constraint:权重变化限制函数
• bias_constraint:偏置值变化限制函数

units用法

在参数介绍的时候就说了units是该层节点数，只能是正整数。用法如下：

model.add(layers.Dense(units=10))

这条命令只是定义了这一层有10个节点，没有激活函数，但是有偏置（偏置是默认的）。但是在第一层需要注意一下，第一层需要定义输入数据形状。（x是输入的数据）

model.add(layers.Dense(units=10,input_shape = (x.shape[1],)))

activation用法

这个参数是用于做非线性变换的。如果是单层网络，那么它输出就是A*X+b的线性输出。而activation很多这里介绍一些常用的：

• relu：keras.activations.relu(x, alpha=0.0, max_value=None, threshold=0.0)整流线性单元。使用默认值时，它返回逐元素的 max(x, 0)否则，它遵循：
  • if x >= max_value：f(x) = max_value
  • elif threshold <= x < max_value：f(x) = x
  • else：f(x) = alpha * (x - threshold)

relu激活函数

model.add(layers.Dense(units=10,activation='relu'))

• sigmoid：Sigmoid函数是一个在生物学中常见的S型函数，将变量映射到0,1之间。logistic回归就是用sigmoid函数输出概率值。

  
  
  sigmoid激活函数

model.add(layers.Dense(units=10,activation='sigmoid'))

• tanh：双曲正切激活函数，这个与sigmoid的区别是压缩到了[-1，1].

  
  
  image.png

model.add(layers.Dense(units=10,activation='tanh'))

除了上面的三种激活函数还有：

• elu：指数线性单元。
• selu：可伸缩的指数线性单元（SELU）。
• softplus：Softplus 激活函数。
• softsign：Softsign 激活函数。
• hard_sigmoid：Hard sigmoid 激活函数，计算速度比 sigmoid 激活函数更快。
• exponential：自然数指数激活函数。
• linear：线性激活函数（即不做任何改变）

这个是keras.activation的中文API：Keras 中文文档
具体的各个激活函数的用法可以参考一下。下面是activation在keras的源代码有兴趣可以研究一下

"""Built-in activation functions.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import six
import warnings
from . import backend as K
from .utils.generic_utils import deserialize_keras_object
from .engine import Layer


def softmax(x, axis=-1):
    """Softmax activation function.

    # Arguments
        x: Input tensor.
        axis: Integer, axis along which the softmax normalization is applied.

    # Returns
        Tensor, output of softmax transformation.

    # Raises
        ValueError: In case `dim(x) == 1`.
    """
    ndim = K.ndim(x)
    if ndim == 2:
        return K.softmax(x)
    elif ndim > 2:
        e = K.exp(x - K.max(x, axis=axis, keepdims=True))
        s = K.sum(e, axis=axis, keepdims=True)
        return e / s
    else:
        raise ValueError('Cannot apply softmax to a tensor that is 1D. '
                         'Received input: %s' % x)


def elu(x, alpha=1.0):
    """Exponential linear unit.

    # Arguments
        x: Input tensor.
        alpha: A scalar, slope of negative section.

    # Returns
        The exponential linear activation: `x` if `x > 0` and
        `alpha * (exp(x)-1)` if `x < 0`.

    # References
        - [Fast and Accurate Deep Network Learning by Exponential
           Linear Units (ELUs)](https://arxiv.org/abs/1511.07289)
    """
    return K.elu(x, alpha)


def selu(x):
    """Scaled Exponential Linear Unit (SELU).

    SELU is equal to: `scale * elu(x, alpha)`, where alpha and scale
    are predefined constants. The values of `alpha` and `scale` are
    chosen so that the mean and variance of the inputs are preserved
    between two consecutive layers as long as the weights are initialized
    correctly (see `lecun_normal` initialization) and the number of inputs
    is "large enough" (see references for more information).

    # Arguments
        x: A tensor or variable to compute the activation function for.

    # Returns
       The scaled exponential unit activation: `scale * elu(x, alpha)`.

    # Note
        - To be used together with the initialization "lecun_normal".
        - To be used together with the dropout variant "AlphaDropout".

    # References
        - [Self-Normalizing Neural Networks](https://arxiv.org/abs/1706.02515)
    """
    alpha = 1.6732632423543772848170429916717
    scale = 1.0507009873554804934193349852946
    return scale * K.elu(x, alpha)


def softplus(x):
    """Softplus activation function.

    # Arguments
        x: Input tensor.

    # Returns
        The softplus activation: `log(exp(x) + 1)`.
    """
    return K.softplus(x)


def softsign(x):
    """Softsign activation function.

    # Arguments
        x: Input tensor.

    # Returns
        The softsign activation: `x / (abs(x) + 1)`.
    """
    return K.softsign(x)


def relu(x, alpha=0., max_value=None, threshold=0.):
    """Rectified Linear Unit.

    With default values, it returns element-wise `max(x, 0)`.

    Otherwise, it follows:
    `f(x) = max_value` for `x >= max_value`,
    `f(x) = x` for `threshold <= x < max_value`,
    `f(x) = alpha * (x - threshold)` otherwise.

    # Arguments
        x: Input tensor.
        alpha: float. Slope of the negative part. Defaults to zero.
        max_value: float. Saturation threshold.
        threshold: float. Threshold value for thresholded activation.

    # Returns
        A tensor.
    """
    return K.relu(x, alpha=alpha, max_value=max_value, threshold=threshold)


def tanh(x):
    """Hyperbolic tangent activation function.

    # Arguments
        x: Input tensor.

    # Returns
        The hyperbolic activation:
        `tanh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))`

    """
    return K.tanh(x)


def sigmoid(x):
    """Sigmoid activation function.

    # Arguments
        x: Input tensor.

    # Returns
        The sigmoid activation: `1 / (1 + exp(-x))`.
    """
    return K.sigmoid(x)


def hard_sigmoid(x):
    """Hard sigmoid activation function.

    Faster to compute than sigmoid activation.

    # Arguments
        x: Input tensor.

    # Returns
        Hard sigmoid activation:

        - `0` if `x < -2.5`
        - `1` if `x > 2.5`
        - `0.2 * x + 0.5` if `-2.5 <= x <= 2.5`.
    """
    return K.hard_sigmoid(x)


def exponential(x):
    """Exponential (base e) activation function.

    # Arguments
        x: Input tensor.

    # Returns
        Exponential activation: `exp(x)`.
    """
    return K.exp(x)


def linear(x):
    """Linear (i.e. identity) activation function.

    # Arguments
        x: Input tensor.

    # Returns
        Input tensor, unchanged.
    """
    return x


def serialize(activation):
    return activation.__name__


def deserialize(name, custom_objects=None):
    return deserialize_keras_object(
        name,
        module_objects=globals(),
        custom_objects=custom_objects,
        printable_module_name='activation function')


def get(identifier):
    """Get the `identifier` activation function.

    # Arguments
        identifier: None or str, name of the function.

    # Returns
        The activation function, `linear` if `identifier` is None.

    # Raises
        ValueError if unknown identifier
    """
    if identifier is None:
        return linear
    if isinstance(identifier, six.string_types):
        identifier = str(identifier)
        return deserialize(identifier)
    elif callable(identifier):
        if isinstance(identifier, Layer):
            warnings.warn(
                'Do not pass a layer instance (such as {identifier}) as the '
                'activation argument of another layer. Instead, advanced '
                'activation layers should be used just like any other '
                'layer in a model.'.format(
                    identifier=identifier.__class__.__name__))
        return identifier
    else:
        raise ValueError('Could not interpret '
                         'activation function identifier:', identifier)