现代C++中的从头开始深度学习:激活函数

一、说明

        让我们通过在C++中实现激活函数来获得乐趣。人工神经网络是生物启发模型的一个例子。在人工神经网络中,称为神经元的处理单元被分组在计算层中,通常用于执行模式识别任务。

        在这个模型中,我们通常更喜欢控制每一层的输出以服从一些约束。例如,我们可以将神经元的输出限制为 [0, 1]、[0, ∞] 或 [-1,+1] 的区间。另一个非常常见的场景是保证来自同一层的神经元总是相加 1。应用这些约束的方法是使用激活函数

在这个故事中,我们将介绍 5 个重要的激活函数:sigmoid、tanh、ReLU、identity 和 Softmax。

二、关于本系列

在本系列中,我们将学习如何仅使用普通和现代C++对必须知道的深度学习算法进行编码,例如卷积、反向传播、激活函数、优化器、深度神经网络等。

现代C++中的从头开始深度学习:激活函数_第1张图片

这个故事是:C++中的激活函数

查看其他故事:

0 — 现代C++深度学习编程基础

1 — 在C++中编码 2D 卷积

2 — 使用 Lambda 的成本函数

3 — 实现梯度下降

...更多内容即将推出。

三、sigmoid激活

从历史上看,最著名的激活是Sigmoid函数:

现代C++中的从头开始深度学习:激活函数_第2张图片

Sigmoid 函数和一阶导数

此图表显示了 sigmoid 的三个重要属性:

  • 其输出限制在 0 和 1 之间;
  • 它是平滑的,或者用更好的数学术语来说,它是可微分的;
  • 它是S形的。

你应该想知道为什么形状很重要?S 形模型意味着曲线类似于原点邻域中的线性曲线:

现代C++中的从头开始深度学习:激活函数_第3张图片

这有助于更快地收敛小输入。有两种方法可以定义 sigmoid 公式:

现代C++中的从头开始深度学习:激活函数_第4张图片

这两个公式是等效的,但在实现时,我们更愿意使用后者:

double sigmoid(double x)
{
    return 1. / (1. + exp(-x));
}

我们更喜欢第二个公式的原因是第一个公式在数值上更不稳定。很多时候,我们在实现 sigmoid 时使用短路:

double sigmoid(double x)
{
    double result;
    if (x >= 45.) result = 1.;
    else if (x <= -45.) result = 0.;
    else result = 1. / (1. + exp(-x));
    return result;
}

这节省了大量处理并避免了以下情况 |x|很大。

四、sigmoid导数

        使用链式法则,我们可以找到 sigmoid 导数为:

        为方便起见,我们将 sigmoid 及其一阶导数分组为一个函子:

class Sigmoid : public ActivationFunction
{
    public:

        virtual Matrix operator()(const Matrix &z) const
        {
            return z.unaryExpr(std::ref(Sigmoid::helper));
        }

        virtual Matrix jacobian(const Vector &z) const
        {
            Vector output = (*this)(z);

            Vector diagonal = output.unaryExpr([](double y) {
                return (1. - y) * y;
            });

            DiagonalMatrix result = diagonal.asDiagonal();

            return result;
        }

    private:

        static double helper(double z)
        {
            double result;
            if (z >= 45.) result = 1.;
            else if (z <= -45.) result = 0.;
            else result = 1. / (1. + exp(-z));
            return result;
        }

};

我们将看到在介绍反向传播算法时如何使用激活函数导数。

Sigmoid 主要用于二元分类器或回归系统的输出层,其中结果始终为非负。如果输出可以是负值,请考虑使用下面描述的 Tanh 激活。


五、Tanh 激活

        顾名思义,tanh 激活由双曲正切三角函数定义:

        与 sigmoid 一样,tanh 也是 S 形且可微的。然而,tanh 的界限是 -1 和 1:

现代C++中的从头开始深度学习:激活函数_第5张图片

Tanh 函数和一阶导数

tanh 激活和 sigmoid 激活紧密相关:

请注意,由于 tanh 可以输出负值,因此我们不能将其与 logcosh 等损失函数一起使用。

tanh 的一阶导数为:

我们可以将 tanh 及其导数打包到一个函子中:

class Tanh : public ActivationFunction
{
    public:

        virtual Matrix operator()(const Matrix &z) const
        {
            return z.unaryExpr(std::ref(tanh));
        }

        virtual Matrix jacobian(const Vector &z) const
        {
            Vector output = (*this)(z);

            Vector diagonal = output.unaryExpr([](double y) {
                return (1. - y * y);
            });

            DiagonalMatrix result = diagonal.asDiagonal();

            return result;
        }
};

六、RELU

        Sigmoid 和 Tanh 的一个问题是它们的计算成本非常高,使得训练时间更长。ReLU是一个简单的激活:

现代C++中的从头开始深度学习:激活函数_第6张图片

ReLU活化和一阶导数

由于ReLU是一个简单的比较,因此与其他函数相比,其计算成本非常低。

我们可以按如下方式实现 ReLU:

class ReLU : public ActivationFunction
{

    public:

        virtual Matrix operator()(const Matrix &z) const
        {
            return z.unaryExpr([](double v) {
                return std::max(0., v);
            });
        }

        virtual Matrix jacobian(const Vector &z) const
        {

            Vector output = (*this)(z);
            Vector diagonal = output.unaryExpr([](double y) {
                double result = 0.;
                if (y > 0) result = 1.; 
                return result;
            });

            DiagonalMatrix result = diagonal.asDiagonal();

            return result;
        }

};

        相关要点是:

  • 它对负值有界,但对正 x 值未绑定:[0, ∞]
  • 当 x = 0 时,它是不可微分的。在实践中,我们通过假设当 x = 0 时导数 dRelu(x)/dx 为 0 来放宽此条件。

        由于 ReLU 基本上由单个比较组成,因此我们谈论的是一个非常快速的计算操作。它的第一阶导数也可以快速计算:

        尽管有其优点,但ReLu有三个主要缺点:

  • 由于它不是正有界的,我们不能使用它来控制输出到 [0, 1]。正因为如此,在实践中,ReLU通常只存在于内部(隐藏)层中。
  • 由于 ReLu 对于任何 x < 0 都是 0,有时我们的模型在训练过程中只是“死亡”,因为部分或所有神经元都停留在仅输出 0 的状态。
  • 由于 ReLU 的导数在 x = 0 时不连续,因此对于某些输入,模型的训练可能不稳定。

有一些替代方法可以解决这些问题(参见Softplus,leakyReLU,ELU和GeLU)。然而,由于相当大的好处,ReLU仍然广泛用于现实世界的模型。

七、身份激活

        身份激活的定义很简单:

        其导数为:

        使用身份激活意味着神经元的输出不会以任何方式被修改。在这种情况下,实现非常简单:

class Identity : public ActivationFunction
{
    public:
        virtual Matrix operator()(const Matrix &z) const { return z; }

        virtual Matrix jacobian(const Vector &z) const
        {

            Vector diagonal = Vector::Ones(z.rows());

            DiagonalMatrix result = diagonal.asDiagonal();

            return result;
        }
};

现代C++中的从头开始深度学习:激活函数_第7张图片

恒等式和一阶导数

八、softmax

        考虑到我们有一张宠物的照片,我们需要确定它是哪种动物:狗?一只猫?仓鼠?一只鸟?豚鼠?在机器学习中,我们通常将此类问题建模为分类问题,并将模型称为分类器

        Softmax非常适合作为分类器的输出,因为它实际上表示离散概率分布。例如,请考虑以下示例:

现代C++中的从头开始深度学习:激活函数_第8张图片

猫、狗和鸟的分类器

在前面的示例中,网络非常确定图像中的宠物是猫。在下一个示例中,模型将图像评分为狗:

现代C++中的从头开始深度学习:激活函数_第9张图片

在深度学习模型中,我们使用 Softmax 来表示这种类型的输出。

这张惊人的宠物照片是由Amber Janssens拍摄的

8.1 定义SoftMax

        Softmax的原始公式是:

现代C++中的从头开始深度学习:激活函数_第10张图片

        这个公式意味着,如果我们有 k 个神经元,第 i 个神经元的输出由 x i 的指数除以每个神经元 xj 的指数之和给出。

Softmax的第一个实现可以是:

const auto buggy_softmax(const Vector &z) {

    Vector expo = z.array().exp();
    Vector sums = expo.colwise().sum();
    Vector result = expo.array().rowwise() / sums.transpose().array();
    return result;

};

我们很快就会看到这种实现存在严重缺陷。但是这段代码的工作是说明softmax最重要的方面:每个神经元的结果取决于每个单独的输入。

我们可以运行以下代码:

Vector input1 = Vector::Zero(3);
input1 << 0.1, 1., -2.;

std::cout << "Input 1:\n" << input1.transpose() << "\n\n";
std::cout << "results in:\n" << buggy_softmax(input1).transpose() << "\n\n";

到输出:

现代C++中的从头开始深度学习:激活函数_第11张图片

Softmax最重要的两个方面是:

  • 所有神经元的总和始终为 1
  • 每个神经元值在区间 [0, 1] 内

8.2 实现SoftMax

        我们之前的 softmax 实现的问题在于指数函数增长非常快。例如,e¹⁰ 大约是 22,026,但 e¹⁰⁰ 是 2.688117142×10 ⁴³,这是一个令人生畏的巨大数字。事实证明,即使我们使用适度的数字作为输入,我们的实现也会失败:

Vector input2 = Vector::Zero(4);
input2 << 100, 1000., -500., 200.;

std::cout << "Input 2:\n" << input2.transpose() << "\n\n";
std::cout << "results in:\n" << buggy_softmax(input2).transpose() << "\n\n";
std::cout << "using the buggy implementation.\n";

现代C++中的从头开始深度学习:激活函数_第12张图片

        发生这种情况是因为C++浮点具有固定的表示形式。使用常规 64 位处理器,任何通过 750 或更多字符的调用都会导致数字。cmath exp(x)inf

        幸运的是,我们可以使用以下技巧来修复它:

现代C++中的从头开始深度学习:激活函数_第13张图片

        其中 m 是最大输入:

        现在,通过修复代码,我们得到:

const auto good_softmax(const Vector &z) {

    Vector maxs = z.colwise().maxCoeff();
    Vector reduc = z.rowwise() - maxs.transpose();
    Vector expo = reduc.array().exp();
    Vector sums = expo.colwise().sum();
    Vector result = expo.array().rowwise() / sums.transpose().array();
    return result;

};

现代C++中的从头开始深度学习:激活函数_第14张图片

溢出是数值不稳定的一个来源。

当我们开发现实世界的深度学习系统时,数值稳定性是一个非常普遍的问题。

8.3 Softmax衍生产品

        Softmax和其他激活之间存在非常明显的差异。通常,像sigmoid或ReLU这样的激活是系数操作,即一个系数的值不会影响其他系数。当然,在 Softmax 中,这不是真的,因为所有值都需要求和 1。这种依赖性使得softmax导数的计算有点棘手。尽管如此,经过一点点的计算并使用我们的老朋友链规则,我们可以弄清楚:

现代C++中的从头开始深度学习:激活函数_第15张图片

如果您想阅读此衍生品的发展,请告诉我。

例如,如果我们有 5 个神经元,则每个神经元相对于同一层中每个神经元的导数由下式给出:

现代C++中的从头开始深度学习:激活函数_第16张图片

这个导数将在下一个故事中应用,当我们训练第一个分类器时。

九、包装SoftMax以供进一步使用

最后,我们可以按如下方式实现 Softmax 函子:

class Softmax : public ActivationFunction
{
    public:

        virtual Matrix operator()(const Matrix &z) const
        {

            if (z.rows() == 1)
            {
                throw std::invalid_argument("Softmax is not suitable for single value outputs. Use sigmoid/tanh instead.");
            }
            Vector maxs = z.colwise().maxCoeff();
            Matrix reduc = z.rowwise() - maxs.transpose();
            Matrix expo = reduc.array().exp();
            Vector sums = expo.colwise().sum();
            Matrix result = expo.array().rowwise() / sums.transpose().array();
            return result;
        }

        virtual Matrix jacobian(const Vector &z) const
        {
            Matrix output = (*this)(z);

            Matrix outputAsDiagonal = output.asDiagonal();

            Matrix result = outputAsDiagonal - (output * output.transpose());

            return result;
        }

};

如今,几乎每个分类器都在输出层中使用 Softmax。我们将在接下来的故事中介绍softmax的一些真实示例。

十、其他激活函数

        还有其他几个激活函数。除了这里描述的那些,我们还可以列出Softplus,Softsign,SeLU,Elu,GeLU,指数,swish等。一般来说,它们是sigmoid或ReLU的一些变体。

十一、结论和下一步

        激活函数是机器学习模型最重要的构建块之一。在这个故事中,我们学习了一些最重要的:Sigmoid,Tanh,ReLU,Identity和Softmax。

        在下一个故事中,我们将深入探讨最重要的深度学习算法的实现:反向传播。从零开始,在C++和本征。

你可能感兴趣的:(机器学习和深度学习,c++,深度学习,开发语言)