个性化阅读
专注于IT技术分析

机器学习基础-规范

点击下载

本文概述

介绍

线性代数是我们在数据科学中需要的基本数学工具之一。对这些概念有所了解可以增加你对各种算法的理解。这确实是数据科学/机器学习道路的绝佳基础。

本教程的目标是通过使用Python / Numpy进行编码来进入数据科学数学。我认为, 就诸如线性代数之类的理论主题编写实用教程会很有用, 因为编写和阅读代码是真正理解数学概念的好方法。最重要的是, 我认为这可能会很有趣!

没有特别的先决条件, 但是如果你不确定什么是矩阵或如何进行点积运算, 那么Ian Goodfellow在我的深度学习书中的系列文章的第一篇(第1至第4篇)就是一个好的开始。

在本教程中, 我们将介绍机器学习和深度学习的重要概念:规范。例如, 该规范被广泛用于评估模型的优劣。到本教程结束时, 你将有望对这个概念有一个更好的直觉, 以及它为什么在机器学习中如此有价值。我们还将看到如何使用范数的导数来训练机器学习算法。

基本设定

首先, 我们将设置将要使用的库:

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

并将一些Latex快捷方式添加到命令bs中, 以显示粗体符号, 并在norm中添加标准符号:

$$
\newcommand\bs[1]{\boldsymbol{#1}}
\newcommand\norm[1]{\left\lVert#1\right\rVert}
$$

$$ \ newcommand \ bs [1] {\ boldsymbol {#1}} \ newcommand \ norm [1] {\ left \ lVert#1 \ right \ rVert} $$

设置的最后一件事是我们将创建的图形的外观:

# Plot parameters
sns.set()
%pylab inline
pylab.rcParams['figure.figsize'] = (4, 4)
plt.rcParams['xtick.major.size'] = 0
plt.rcParams['ytick.major.size'] = 0
Populating the interactive namespace from numpy and matplotlib

让我们从一个简单的例子开始。假设你有一个包含不同功能的歌曲数据集。现在, 假设你要构建一个根据其他特征(例如音乐的流派, 乐器等)来预测歌曲持续时间的模型。你训练了一个模型, 现在希望在预测歌曲持续时间时对其进行评估新歌。一种方法是获取一些新数据, 并使用模型预测歌曲持续时间。由于你知道这些观察的每首歌曲的真实持续时间, 因此可以比较每个观察的真实和预测持续时间。你将在7秒内获得以下结果, 以秒为单位:

errorModel1 = [22, -4, 2, 7, 6, -3, 12]

这些差异可以认为是模型的误差。一个完美的模型将只有0, 而一个非常差的模型将具有巨大的正值或负值。

现在, 假设你尝试使用另一种模型, 最终在预测歌曲持续时间和实际歌曲持续时间之间存在以下差异:

errorModel2 = [14, 9, -13, 19, 8, -21, 4]

如果想找到最好的模型怎么办?一种自然的方法是将这些误差的绝对值之和。使用绝对值是因为负误差(真实持续时间小于预测持续时间)也是一个误差。总误差越小的模型越好:

totalErrorModel1 = np.sum(np.abs(errorModel1))
totalErrorModel1
56
totalErrorModel2 = np.sum(np.abs(errorModel2))
totalErrorModel2
88

看起来模型1比模型2更好。

恭喜你!你已经为每个模型计算了误差向量的范数!

你可以将范数视为向量的长度。为了对它的图形表示有所了解, 让我们再次以前面的示例为例。误差向量是多维的:每个观测值只有一个维度。在最后一个示例中, 有7个观测值导致7个维度。表示7个维度仍然非常困难, 因此让我们再次简化示例并仅保留2个观察值:

errorModel1 = [22, -4]
errorModel2 = [14, 9]

现在我们可以考虑数组的第一个元素是x坐标, 第二个元素是y坐标来表示这些向量。我们将首先编写一个函数来轻松绘制矢量并了解其表示形式。

我们需要一个函数来帮助我们绘制向量。让我们从使用它的方式开始。我们想要给出与向量坐标相对应的数组列表, 并获得这些向量的图。假设我们还可以提供一个颜色数组以区分图上的向量。总结一下, 我们想这样调用函数:

plotVectors([vector1, vector2], ['red', 'blue'])

让我们编写以下函数:

def plotVectors(vecs, cols, alpha=1):
    """
    Plot set of vectors.

    Parameters
    ----------
    vecs : array-like
        Coordinates of the vectors to plot. Each vector is in an array. For
        instance: [[1, 3], [2, 2]] can be used to plot 2 vectors.
    cols : array-like
        Colors of the vectors. For instance: ['red', 'blue'] will display the
        first vector in red and the second in blue.
    alpha : float
        Opacity of vectors

    Returns:

    fig : instance of matplotlib.figure.Figure
        The figure of the vectors
    """
    plt.axvline(x=0, color='#A9A9A9', zorder=0)
    plt.axhline(y=0, color='#A9A9A9', zorder=0)

    for i in range(len(vecs)):
        if (isinstance(alpha, list)):
            alpha_i = alpha[i]
        else:
            alpha_i = alpha
        if (len(vecs[i])==2):
            x = np.concatenate([[0, 0], vecs[i]])
        elif (len(vecs[i])==4):
            x = vecs[i]
        plt.quiver([x[0]], [x[1]], [x[2]], [x[3]], angles='xy', scale_units='xy', scale=1, color=cols[i], alpha=alpha_i)

它需要向量数组来绘制(vecs)及其颜色(cols)作为输入。如果在向量中仅指定2个尺寸, 则该尺寸从(0, 0)开始。在幕后, 我们对向量数组进行迭代, 并使用plt.quiver()绘制它们。

让我们使用新函数来绘制模型1和2的误差:

plotVectors([errorModel1, errorModel2], [sns.color_palette()[0], sns.color_palette()[1]])

plt.xlim(-1, 25)
plt.ylim(-5, 10)
plt.show()
机器学习基础-规范1

注意:我们没有在函数中包含plt.show(), 以便能够添加带有此处限制的绘图配置。

注意2:我们通过sns.color_palette()手动使用了seaborn的颜色

因此, 每个模型都有一个误差向量。更好的模型就是与较小向量相对应的模型。计算向量长度的一种方法是使用勾股定理:$ \ sqrt {x ^ 2 + y ^ 2} $。我们可以计算两个向量的长度:

# Lenght of the vector errorModel1
np.sqrt(errorModel1[0]**2+errorModel1[1]**2)
22.360679774997898
# Lenght of the vector errorModel2
np.sqrt(errorModel2[0]**2+errorModel2[1]**2)
16.643316977093239

恭喜你!你只计算了误差向量的另一个范数。第一个模型的误差向量的长度是$ 22.36 $, 第二个模型的误差向量的长度是$ 16.64 $左右。在这种情况下, 第二个模型更好, 但是请记住我们只是使用了前两个值。

我们首先计算了误差之和, 但也可以使用勾股定理来计算向量的范数。这是两个不同的规范, 它表明存在多种计算规范的方法。

向量的范数可以是将向量映射为正值的任何函数。可以使用不同的功能, 我们将看到一些示例。如果这些函数具有以下特性, 则可以将它们称为规范:

  • 规范是非负值。如果你将规范视为一个长度, 则可以轻松了解为什么它不能为负。
  • 当且仅当向量为零向量时, 范数为$ 0 $。
  • 规范尊重三角形不等式。见下文。
  • $ \ norm {k \ cdot \ bs {u}} = \ norm {k} \ cdot \ norm {\ bs {u}} $。在这里, $ k $是一个标量, $ \ bs {u} $是一个向量。向量乘以标量的范数等于此标量的绝对值乘以向量的范数。

通常用两个横杠写成:$ \ norm {\ bs {x}} $

上面我们已经看到, 函数成为范数的一个条件是它尊重三角形不等式。这仅意味着某些向量之和的范数小于或等于这些向量的范数的总和:

$$ \ norm {\ bs {u} + \ bs {v}} \ leq \ norm {\ bs {u}} + \ norm {\ bs {v}} $$

范例1。

为了说明这意味着什么, 我们将使用两个向量, 每个向量包含两个元素(同样, 可用于表示为x和y坐标)。我们的向量是:

$$ \ bs {u} = \ begin {bmatrix} 1和6 \ end {bmatrix} $$

u = np.array([1, 6])
u
array([1, 6])

$$ \ bs {v} = \ begin {bmatrix} 4和2 \ end {bmatrix} $$

v = np.array([4, 2])
v
array([4, 2])

让我们比较一下:

$$ \ norm {\ bs {u} + \ bs {v}} $$

和:

$$ \ norm {\ bs {u}} + \ norm {\ bs {v}} $$

我们将在以后看到不同类型的规范, 但是现在, 我们将使用经典的规范:欧几里得规范($ L ^ 2 $)。可以使用Numpy函数np.linalg.norm()计算$ L ^ 2 $范数(请参阅文档的更多详细信息)。

$$ \ norm {\ bs {u} + \ bs {v}} = \ sqrt {(1 + 4)^ 2 +(6 + 2)^ 2} = \ sqrt {89} \约9.43 $$

稍后我们将详细介绍什么是$ L ^ 1 $或$ L ^ 2 $规范。

np.linalg.norm(u+v)
9.4339811320566032

$$ \ norm {\ bs {u}} + \ norm {\ bs {v}} = \ sqrt {1 ^ 2 + 6 ^ 2} + \ sqrt {4 ^ 2 + 2 ^ 2} = \ sqrt {37 } + \ sqrt {20} \约10.55 $$

np.linalg.norm(u)+np.linalg.norm(v)
10.554898485297798

我们可以看到三角形不等式受到尊重, 因为:

$$ \ norm {\ bs {u} + \ bs {v}} \ leq \ norm {\ bs {u}} + \ norm {\ bs {v}} $$

图形说明

你将看到该定理的图形表示使其变得微不足道。我们将使用plotVectors函数绘制矢量$ \ bs {u} $, $ \ bs {v} $和$ \ bs {u} + \ bs {v} $, 并添加一些文本来标识矢量:

u = np.array([0, 0, 1, 6])
v = np.array([0, 0, 4, 2])
w = u+v

u_bis = [u[2], u[3], v[2], v[3]]

plotVectors([u, u_bis, w], [sns.color_palette()[0], sns.color_palette()[1], sns.color_palette()[2]])

plt.xlim(-2, 6)
plt.ylim(-2, 9)

plt.text(-1, 3.5, r'$||\vec{u}||$', color=sns.color_palette()[0], size=20)
plt.text(2.5, 7.5, r'$||\vec{v}||$', color=sns.color_palette()[1], size=20)
plt.text(2, 2, r'$||\vec{u}+\vec{v}||$', color=sns.color_palette()[2], size=20)

plt.show()
plt.close()
机器学习基础-规范2

$ \ bs {u} $的长度加上$ \ bs {v} $的长度大于向量$ \ bs {u} + \ bs {b} $的长度。从几何上讲, 这仅意味着两点之间的最短路径是一条直线!

我们已经看到该函数所需要的条件称为规范。这意味着可以将多个功能用作规范。稍后我们将看到这些不同规范的优缺点。我们将$ p $ -norm称为依赖于$ p $的以下函数类别:

$$ \ norm {\ bs {x}} _ p =(\ sum_i | \ bs {x} _i | ^ p)^ {1 / p} $$

让我们逐步研究这个方程式。我们可以看到有一个元素的总和, 因此我们可以将其视为$ i $元素的迭代:

  1. $ \ vert \ bs {x} _i \ vert $计算$ i $ th元素的绝对值
  2. $ \ vert \ bs {x} _i \ vert ^ p $掌权$ p $
  3. $ \ sum_i \ vert \ bs {x} _i \ vert ^ p $对所有这些加功率的绝对值求和
  4. $(\ sum_i \ vert \ bs {x} _i \ vert ^ p)^ {1 / p} $取幂$ \ frac {1} {p} $

使用使用这些广泛使用的$ p $ -norms的示例将很清楚。

如果$ p = 0 $, 则公式变为:

$$ \ norm {\ bs {x}} _ 0 =(\ sum_i | \ bs {x} _i | ^ 0)^ {1/0} $$

让我们看看它的意思。使用绝对值幂$ 0 $将为每个非$ 0 $值提供$ 1 $, 为$ 0 $提供$ 0 $。

因此, 该范数对应于向量中非零元素的数量。这并不是真正的规范, 因为如果将向量乘以$ \ alpha $, 则此数字相同(上面的规则4)。

如果$ p = 1 $, 我们就可以得到绝对值的总和。这是我们在本教程开始时直观使用的内容:

机器学习基础-规范3

欧几里得范数是$ p = 2 $的$ p $范数。这可能是使用更平方的$ L ^ 2 $范数的范数(请参见下文)。

$$ \ norm {\ bs {x}} _ 2 =(\ sum_i \ bs {x} _i ^ 2)^ {1/2} = \ sqrt {\ sum_i \ bs {x} _i ^ 2} $$

我们可以注意到, 因为$ x $是平方的, 所以不再需要绝对值。这就是我们使用上述勾股定理计算向量长度时所使用的方法。

让我们来看这个规范的另一个例子:

示例2

在图形上, 欧几里得范数对应于矢量从原点到通过线性组合(毕达哥拉斯定理)获得的点的长度。我们将在二维中看到一个示例:向量$ \ bs {u} $具有两个值, 分别对应于$ x $坐标和$ y $坐标。如果使用这些坐标绘制点并从原点到该点绘制一个向量, 则$ L ^ 2 $范数将是该向量的长度。

例如:

$$ \ bs {u} = \ begin {bmatrix} 3 \\ 4 \ end {bmatrix} $$

让我们开始使用公式计算范数:

机器学习基础-规范4

因此, $ L ^ 2 $范数为$ 5 $。

顺便提一下, 请注意, 可以使用Numpy的linalg.norm()函数来计算$ L ^ 2 $范数:

np.linalg.norm([3, 4])
5.0

这是向量的图形表示:

u = np.array([3, 4])

plt.ylim(-1, 5)
plt.xlim(-1, 5)
plotVectors([u], [sns.color_palette()[0]])
机器学习基础-规范5

我们可以看到向量从原点(0, 0)到(3, 4), 其长度为5。

在这种情况下, 矢量位于二维空间中, 但这也代表了更大的尺寸。

$$ \ bs {u} = \ begin {bmatrix} u_1 \\ u_2 \\ \ cdots \\ u_n \ end {bmatrix} $$

$$ \ norm {\ bs {u}} _ 2 = \ sqrt {u_1 ^ 2 + u_2 ^ 2 + \ cdots + u_n ^ 2} $$

$$ \ norm {\ bs {u}} _ 2 ^ 2 =(\ sqrt {\ sum_i \ bs {x} _i ^ 2})^ 2 = \ sum_i \ bs {x} _i ^ 2 $$

平方的$ L ^ 2 $范数很方便, 因为它去除了平方根, 并且我们最终得到了向量每个平方值的简单和。

平方的欧几里得范数在机器学习中得到了广泛的应用, 部分原因是它可以使用矢量运算$ \ bs {x} ^ \ text {T} \ bs {x} $进行计算。通过优化可以提高性能。有关更多详细信息, 请参见此处和此处。

范例3。

在此示例中, 我们将看到可以使用矢量化运算来计算平方的欧几里得范数。让我们从向量$ \ bs {x} $开始:

$$ \ bs {x} = \ begin {bmatrix} 2 \\ 5 \\ 3 \\ 3 \ end {bmatrix} $$

和往常一样, 我们将使用代码来检查过程。首先, 让我们创建Numpy向量$ \ bs {x} $:

x = np.array([[2], [5], [3], [3]])
x
array([[2], [5], [3], [3]])

现在让我们对该向量进行转置。这只会将初始列向量转换为行向量:

$$ \ bs {x} ^ \ text {T} = \ begin {bmatrix} 2&5&3&3 \ end {bmatrix} $$

我们可以使用Numpy对象的T方法计算$ \ bs {x} $的转置:

x.T
array([[2, 5, 3, 3]])

$ \ bs {x} $和$ \ bs {x} ^ \ text {T} $的点积(如果需要有关点积的提示, 请参见此处)实际上对应于每个元素本身的乘法:

机器学习基础-规范6

这正是欧几里得模平方的定义!

让我们与Numpy核对一下。记住(并尝试说服自己), 点积中向量的顺序很重要:

euclideanNorm = x.T.dot(x)
euclideanNorm
array([[47]])

这应该是我们平方的欧几里得范数!让我们根据$ L ^ 2 $范数进行计算, 然后对其平方以检查是否正确:

np.linalg.norm(x)**2
47.0

有用!与其他规范相比, 使用矢量化运算的可能性是一个巨大的优势。

$ L ^ 2 $平方的平方的导数

我们已经看到, 可以通过总结误差向量来使用规范来评估模型的优劣。

现在, 我们想更进一步, 知道如何更改模型的参数以减少总体误差。为此, 我们可以使用成本函数, 该函数将模型的误差与参数值的函数相关联。梯度下降算法可用于查找该函数的最小值。通过根据每个参数计算导数来完成梯度下降(偏导数=梯度)。这就是为什么这对于能够有效计算导数至关重要。

确实, 平方的L ^ 2 $范数的一大优点是它的偏导数易于计算。让我们有以下向量:

$$ \ bs {u} = \ begin {bmatrix} u_1 \\ u_2 \\ \ cdots \\ u_n \ end {bmatrix} $$

我们已经看到, 其平方的L ^ 2 $范数的计算公式为:

$$ \ norm {\ bs {u}} _ 2 ^ 2 = u_1 ^ 2 + u_2 ^ 2 + \ cdots + u_n ^ 2 $$

然后, 为了计算偏导数, 我们将所有其他变量视为常数。例如, 根据$ u_1 $的偏导数是$ u_1 ^ 2 + a $的导数($ a $是与所有其他变量相对应的常数)。因此, 我们有以下偏导数:

$$ \开始{cases} \ dfrac {d \ norm {\ bs {u}} _ 2 ^ 2} {du_1} = 2u_1 \\ \ dfrac {d \ norm {\ bs {u}} _ 2 ^ 2} {du_2 } = 2u_2 \\ \ cdots \\ \ dfrac {d \ norm {\ bs {u}} _ 2 ^ 2} {du_n} = 2u_n \ end {cases} $$

$ L ^ 2 $平方的平方的梯度的优点在于, 导数不依赖于其他变量。我们将看到, $ L ^ 2 $范数不是这种情况。

$ L ^ 2 $范数的导数

在$ L ^ 2 $范数的情况下, 导数更为复杂, 并考虑了向量的每个元素。让我们以最后一个向量$ \ bs {u} $为例。 $ L ^ 2 $范数为:

$$ \ norm {\ bs {u}} _ 2 = \ sqrt {(u_1 ^ 2 + u_2 ^ 2 + \ cdots + u_n ^ 2)} =(u_1 ^ 2 + u_2 ^ 2 + \ cdots + u_n ^ 2) ^ {\ frac {1} {2}} $$

让我们根据$ u_1 $计算它的导数:

机器学习基础-规范7

我们可以看到$ u_1 $的偏导数仍然包含$ u_2 … u_n $。其他渐变遵循相同的结构:

$$ \开始{cases} \ dfrac {d \ norm {\ bs {u}} _ 2} {du_1} = \ dfrac {u_1} {\ sqrt {(u_1 ^ 2 + u_2 ^ 2 + \ cdots + u_n ^ 2 }}} \\ \ dfrac {d \规范{\ bs {u}} _ 2} {du_2} = \ dfrac {u_2} {\ sqrt {(u_1 ^ 2 + u_2 ^ 2 + \ cdots + u_n ^ 2)} } \\ \ cdots \\ \ dfrac {d \ norm {\ bs {u}} _ 2} {du_n} = \ dfrac {u_n} {\ sqrt {(u_1 ^ 2 + u_2 ^ 2 + \ cdots + u_n ^ 2 }}} \\ \结束{cases} $$

其他注意事项

$ L ^ 2 $平方的范数很好, 但是它的一个问题是, 由于函数缓慢增加, 因此很难区分0和较小的值。

我们可以通过图形比较$ L ^ 2 $范数和$ L ^ 2 $范数来看到这一点。 $ z $轴对应于范数的值, $ x $-和$ y $轴对应于两个参数。对于2个以上的维度, 同样的情况也适用, 但是很难将其形象化。

$ L ^ 2 $范数:

机器学习基础-规范8

$ L ^ 2 $平方的平方:

机器学习基础-规范9

为了进行比较, 这是$ L ^ 1 $范数:

机器学习基础-规范10

这些情节是在本网站的帮助下完成的。如果需要移动它们以捕捉其形状, 请去绘制这些规范。

它是$ L ^ \ infty $范数, 对应于向量最大元素的绝对值。

$$ \ norm {\ bs {x}} _ \ infty = \ max \ limits_i | x_i | $$

机器学习基础-规范11

这等效于在展平后采用矩阵的$ L ^ 2 $范数。

可以使用相同的Numpy函数:

A = np.array([[1, 2], [6, 4], [3, 2]])
A
array([[1, 2], [6, 4], [3, 2]])
np.linalg.norm(A)
8.3666002653407556

$$ \ bs {x} ^ \ text {T} \ bs {y} = \ norm {\ bs {x}} _ 2 \ cdot \ norm {\ bs {y}} _ 2 \ cos \ theta $$

向量$ \ bs {x} $和$ \ bs {y} $之间的点积可以使用这些向量的$ L ^ 2 $范数来检索。 $ \ theta $是两个向量之间的角度。

范例4。

让我们在2维中采用两个向量:

$$ \ bs {x} = \ begin {bmatrix} 0 \\ 2 \ end {bmatrix} $$

$$ \ bs {y} = \ begin {bmatrix} 2 \\ 2 \ end {bmatrix} $$

下图显示了它们的图形表示:

x = [0, 0, 0, 2]
y = [0, 0, 2, 2]

plotVectors([x, y], [sns.color_palette()[0], sns.color_palette()[1]])

plt.xlim(-1, 3)
plt.ylim(-1, 3)

plt.text(-0.5, 1, r'$\vec{x}$', size=18, color=sns.color_palette()[0])
plt.text(1.5, 0.5, r'$\vec{y}$', size=18, color=sns.color_palette()[1])
<matplotlib.text.Text at 0x10a33b950>
机器学习基础-规范12

我们以这个例子为简单。如我们所见, 角度$ \ theta $等于45°。

首先, 让我们计算向量的点积:

$$ \ bs {x ^ \ text {T} y} = \ begin {bmatrix} 0和2 \ end {bmatrix} \ cdot \ begin {bmatrix} 2 \\ 2 \ end {bmatrix} = 0 \ times2 + 2 \ times2 = 4 $$

x = np.array([0, 2])
y = np.array([2, 2])

x.dot(y)
4

现在让我们计算它们的规范:

$$ \ norm {\ bs {x}} _ 2 = \ sqrt {0 ^ 2 + 2 ^ 2} = \ sqrt {4} = 2 $$

$$ \ norm {\ bs {y}} _ 2 = \ sqrt {2 ^ 2 + 2 ^ 2} = \ sqrt {8} $$

因此, 使用上面的公式, 我们有:

$$ 2 \ times \ sqrt {8} \ times cos(45)= 4 $$

这与点积的结果相同。这是使用numpy的操作。只需注意我们使用Numpy的deg2rad函数, 因为np.cos采用弧度表示角度, 因此我们必须进行转换。

# Note: np.cos take the angle in radian
np.cos(np.deg2rad(45))*2*np.sqrt(8)
4.0000000000000009

一般情况下, $ L ^ 2 $范数(在矩阵的情况下为Frobenius范数)和平方的$ L ^ 2 $范数通常广泛用于机器学习, 深度学习和数据科学中。例如, 规范可以用作成本函数。假设你要使一条线适合一组数据点。找到更好的行的一种方法是从随机参数开始, 然后通过最小化成本函数进行迭代。成本函数是代表模型误差的函数, 因此你希望该误差尽可能小。规范在这里很有用, 因为它为你提供了一种测量此错误的方法。范数会将包含所有错误的向量映射到一个简单的标量, 而cost函数就是该标量, 表示一组参数值。

我们已经看到, 规范不过是归纳为标量的数组而已。我们还注意到, 根据可用于计算它的函数的不同, 存在一些变化。选择使用哪种规范取决于很多要解决的问题, 因为应用一种或多种规范有其优缺点。例如, $ L ^ 1 $规范比$ L ^ 2 $规范更健壮。这意味着$ L ^ 2 $范数更适合异常值, 因为显着的误差值将给出巨大的平方误差值。

本教程基于我的系列中有关Goodfellow等人撰写的《深度学习书》中线性代数一章的文章。

https://www.quora.com/Why-is-L1-regularization-better-than-L2-regularization-provided-that-all-Norms-are-equivalent

https://www.coursera.org/lecture/machine-learning/cost-function-rkTp3

http://www.deeplearningbook.org/contents/linear_algebra.html

https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.linalg.norm.html

https://hadrienj.github.io/deep-learning-book-series-home/

http://christopher5106.github.io/deep/learning/2016/09/16/about-loss-functions-multinomial-logistic-logarithm-cross-entropy-square-errors-euclidian-absolute-frobenius-hinge.html

https://datascience.stackexchange.com/questions/10188/why-do-cost-functions-use-the-square-error

赞(0)
未经允许不得转载:srcmini » 机器学习基础-规范

评论 抢沙发

评论前必须登录!