机器学习基础-规范 _可视化数据

本文概述

介绍
基本设定
$ L ^ 2 $平方的平方的导数
$ L ^ 2 $范数的导数
其他注意事项

介绍线性代数是我们在数据科学中需要的基本数学工具之一。对这些概念有所了解可以增加你对各种算法的理解。这确实是数据科学/机器学习道路的绝佳基础。
本教程的目标是通过使用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 vectorsReturns: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()

文章图片
注意：我们没有在函数中包含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+vu_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()

文章图片
$ \ bs {u} $的长度加上$ \ bs {v} $的长度大于向量$ \ bs {u} + \ bs {b} $的长度。从几何上讲, 这仅意味着两点之间的最短路径是一条直线！
我们已经看到该函数所需要的条件称为规范。这意味着可以将多个功能用作规范。稍后我们将看到这些不同规范的优缺点。我们将$ p $ -norm称为依赖于$ p $的以下函数类别：
$$ \ norm {\ bs {x}} _ p =(\ sum_i | \ bs {x} _i | ^ p)^ {1 / p} $$
让我们逐步研究这个方程式。我们可以看到有一个元素的总和, 因此我们可以将其视为$ i $元素的迭代：

$ \ vert \ bs {x} _i \ vert $计算$ i $ th元素的绝对值
$ \ vert \ bs {x} _i \ vert ^ p $掌权$ p $
$ \ sum_i \ vert \ bs {x} _i \ vert ^ p $对所有这些加功率的绝对值求和
$(\ 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 $, 我们就可以得到绝对值的总和。这是我们在本教程开始时直观使用的内容：

文章图片
欧几里得范数是$ 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} $$
让我们开始使用公式计算范数：

文章图片
因此, $ 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]])

文章图片
我们可以看到向量从原点(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} $的点积(如果需要有关点积的提示, 请参见此处)实际上对应于每个元素本身的乘法：

文章图片
这正是欧几里得模平方的定义！
让我们与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 $计算它的导数：

文章图片
我们可以看到$ 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 $范数：

文章图片
$ L ^ 2 $平方的平方：

文章图片
为了进行比较, 这是$ L ^ 1 $范数：

文章图片
这些情节是在本网站的帮助下完成的。如果需要移动它们以捕捉其形状, 请去绘制这些规范。
它是$ L ^ \ infty $范数, 对应于向量最大元素的绝对值。
$$ \ norm {\ bs {x}} _ \ infty = \ max \ limits_i | x_i | $$

文章图片
这等效于在展平后采用矩阵的$ 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>

文章图片
我们以这个例子为简单。如我们所见, 角度$ \ 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