机器学习——Google 快速入门课程（综合版）

水深无声 2022-10-05 15:55 219阅读 0赞

# 前言 #

本文参考 Google 谷歌官网机器学习的快速入门课程，整体课程比较好理解，供大家学习参考；文章也会结合自己的理解进行优化。看到官网的消息2021/7之后就不提供中文版的机器学习快速入门课程了，英文版还有的。

**目录**

前言

一、机器学习—主要术语（整合版）

二、训练与损失

2.1 前言

2.2 训练模型

2.3 损失函数

2.4 关键词

三、模型迭代

3.1 前言

3.2 训练模型的迭代方法

3.3 关键词（训练、收敛、损失）

3.4 梯度下降法

3.5 梯度下降法实现流程

3.6 关键词-梯度下降法

四、随机梯度下降、批量梯度下降法

4.1 前言

4.2 随机梯度下降（SGD）

4.3 批量梯度下降法（BGD）

五、学习率

5.1 前言

5.2 学习率

5.3 选择学习率

5.4 关键词

六、泛化与过拟合

6.1 前言

6.2 过拟合

6.3 奥卡姆的威廉

6.4 数据集拆分

6.5 机器学习--泛化细则

6.6 小结

6.7 关键词

七、数据集划分

7.1 前言

7.2 划分为训练集、测试集

7.3 划分为训练集、验证集、测试集

7.4 关键词

八、特征工程

8.1 前言

8.2 将原始数据映射到特征

8.3 映射数值

8.4 映射分类值

8.5、稀疏表示法

8.6 良好特征的特点

8.7 关键词

九、正则化L2（简单性）

9.1 前言

9.2 原理

9.3 复杂度

9.4 L2正则化

9.5 简化正则化：Lambda

9.6 正则化和学习率

十、逻辑回归、线性回归

10.1 前言

10.2 计算并返回概率的方式

10.3 S形函数

10.4 逻辑回归推断计算

10.5 逻辑回归的损失函数

10.6 逻辑回归中的正则化

10.7 逻辑回归小结

10.8 线性回归

十一、正则化L1（稀疏性）

11.1 前言

11.2 稀疏性的正则化

11.3 和正则化对比

11.4 关键词

十二、神经网络

12.1 前言

12.2 非线性问题解决方法

12.3 单层神经网络

12.4 两层神经网络

12.5 三层神经网络

12.6 激活函数

12.7 总结

十三、 嵌入Embedding

13.1 协同过滤

13.2 分类输入数据

13.3 稀疏矢量 表示为 数字矢量

13.4 稀疏表示法存在的问题

13.4.1 网络规模

13.4.2 矢量之间缺乏有用意义的联系

13.4.3 解决方案：嵌套

13.5、转换到低维空间

13.6、获取嵌套

13.6.1 标准降维技术

13.6.2 Word2vec

13.6.3 将嵌套训练 作为 大型模型的一部分

--------------------

# 一、机器学习—主要术语（整合版） #

参考谷歌官网对机器学习术语的解释，进行总结并加以描述。

[https://guo-pu.blog.csdn.net/article/details/117442581][https_guo-pu.blog.csdn.net_article_details_117442581]

# 二、训练与损失 #

## 2.1 前言 ##

训练模型表示通过有标签样本学习模型中所有权重w和偏差b的最优值。在监督学习中，机器学习算法通过以下方式构建模型：检查多个样本并尝试找出可最大限度地减少模型的损失；这一过程称为经验风险最小化。

损失是对糟糕预测的惩罚；损失是之歌数值，表示对个单个样本而言模型预测的准确程度。如果模型的预测完成准确，则损失为零，否则损失会较大。

## 2.2 训练模型 ##

训练模型的目标是从所有样本中找到一组平均损失“较少”的权值和偏差。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70][]

红色箭头表示损失；蓝线表示预测。左侧曲线图中的红色箭头比右侧曲线图中的对应红色箭头长得多；即实际点和模型预测相差的距离比较远，差异更大。

左侧显示的是损失较大的模型；右侧显示的是损失较小的模型。

## 2.3 损失函数 ##

平方损失是一种常见的损失函数。线性回归模型使用的是一种称为平方损失（又称![L\_\{2\}][L_2]损失）的损失函数。单个样本的平方损失如下：

= the square of the difference between the label and the prediction
      = (observation - prediction(x))2
      = (y - y')2

**均方误差（MSE）**是指每个样本的平均平方损失。计算MSE，需要求出各个样本的所有平方损失之和，然后除以样本数量：

![MSE = \\frac\{1\}\{n\}\\sum\_\{(x,y)\\epsilon D)\}^\{\}(y - prediction(x))^\{2\}][MSE _ _frac_1_n_sum_x_y_epsilon D_y - prediction_x_2]

其中：

*  (x,y)是指样本；x是指模型进行预测时使用的特征集（比如：温度、年龄等）y是指样本的标签（比如：蟋蟀每分钟的鸣叫次数）
 *  prediction（x）是指权重和偏差与特征集x结合的函数。
 *  D是指包含多个有标签样本的数据集。
 *  n是指D中的样本数量。

MSE常用语回归任务中；分类任务常用交叉熵损失函数。

参考：[https://developers.google.cn/machine-learning/crash-course/descending-into-ml/training-and-loss][https_developers.google.cn_machine-learning_crash-course_descending-into-ml_training-and-loss]

## 2.4 关键词 ##

**经验风险最小化**（ERM，empirical risk minimization），用于选择函数，选择基于训练集的损失降至最低的函数。与结构风险最小化相对。

**均方误差**（MSE，Mean Squared Error），每个样本的平均平方损失。MSE的计算方法是平方损失除以样本数。

**平方损失函数**（squared loss）在线性回归中使用的损失函数（也称为L2损失函数）。改行可计算模型为有标签样本预测的值，和标签的真实值之差的平方。   由于取平方值，该损失函数会放大不佳预测的影响。与L1损失函数相对，平方损失函数对离群值的反应更强烈。

**训练**（training）构建模型的理想参数的过程。

**损失**（Loss）一种衡量指标，用于衡量模型的**预测**偏离其**标签**程度。要确定此值，模型需要定义损失函数。例如：线性回归模型参与均方误差MAS损失函数，分类模型采用交叉熵损失函数。

# 三、模型迭代 #

## 3.1 前言 ##

在训练机器学习模型时，首先对权重和偏差进行初始化猜测，然后反复调整这些猜测参数（权重和偏差），直到获得损失可能最低时的，权重和偏差。

## 3.2 训练模型的迭代方法 ##

机器学习算法用于训练模型的迭代试错过程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70][]

“模型”部分将一个或多个特征作为输入，然后返回一个预测（![y^\{'\}][y]）作为输出。

为了进行简化，不妨考虑采用一个特征，并返回一个预测的模型：

![y^\{'\} = b + w\_\{1\}x\_\{1\}][y_ _ b _ w_1_x_1]

需要考虑为![b][]和![w\_\{1\}][w_1]设置哪些初始值？对于线性回归问题，事实证明初始值并不重要。（注意：如果是其他模型初始化值可能很重要，具体模型具体处理）。我们可以随机初始化，或者采用以下这些无关紧要的值：

*  ![b][] = 0
 *  ![w\_\{1\}][w_1] = 0

假如第一个特征值是10，将该特征值代入预测函数会得到以下结果：

y' = 0 + 0(10)
      y' = 0

然后需要计算损失，上图中的“计算损失”部分是模型使用损失函数，比如：平方损失函数。

损失函数将采用两个输入值：

*  ![y^\{'\}][y]：模型对特征x的预测
 *  y：特征x对应的正确标签。

最后，到图中**“计算参数更新”**部分。机器学习系统就是在此部分检查损失函数的值，并更新![b][]和![w\_\{1\}][w_1]，即为 ![b][]和![w\_\{1\}][w_1]生成新值。

假设这个神秘的绿色框会产生新值，而该值又产生新的参数。这种学习过程会持续迭代，直到该算法发现损失已经降到最低，此时得到一个较好的模型，保存此时的模型参数。

通常，可以不断迭代，直到总体损失不再变化或变化极其缓慢为止，此时模型已经收敛。

## 3.3 关键词（训练、收敛、损失） ##

**训练**（training）构建模型的理想参数的过程。

**收敛**（convergence）收敛通常是指在训练期间达到的一种状态，即经过一定次数的迭代之后，训练损失和验证损失，在每次迭代中的变化都非常小或不再变化。在深度学习中，损失值有时会最终下降之前的多次迭代中保持不变或几乎保持不变，暂时形成收敛的假象。参阅[**早停法**][Link 1]。参阅 Boyd 和 Vandenberghe 合著的 [Convex Optimization][]（《凸优化》）

## 3.4 梯度下降法 ##

在训练模型的迭代中，**“计算参数更新”**部分，可以使用梯度下降法实现。

假设我们有时间和计算资源来计算![w\_\{1\}][w_1]的所有可能值的损失。对于我们一直在研究的回归问题，所产生的损失与![w\_\{1\}][w_1]的图形始终是凸性，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 1][]

回归问题产生的损失与权重为凸形。

凸形问题只有一个最低点；即只存在一个斜率正好为0的位置。这个最小值就是损失函数收敛之处。

通过计算整个数据集中![w\_\{1\}][w_1]每个可能值的损失函数来找到收敛点，这种方法效率太低了。我们来研究一种更好的机制，这种机制在机器学习领域非常热门，称为梯度下降法。

## 3.5 梯度下降法实现流程 ##

梯度下降法的第一个阶段是为![w\_\{1\}][w_1]选择一个初始值（起点），下图显示的是我们选择了一个稍大于0的起点：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 2][]

然后，梯度下降法会计算损失曲线在起点处的梯度。梯度是偏导数的矢量；它可以让模型了解那个方向距离目标“更近”或“更远”。

**详细了解的偏导数和梯度**

这里主要用到微积分的知识，通常开源的机器学习框架已经帮我们计算好梯度了，比如像TensorFlow。

--------------------

**偏导数**

多变量函数值的是具有多个参数的函数，例如：![f(x,y) = e^\{2y\} sin(x)][f_x_y_ _ e_2y_ sin_x]

![f][] 想对于![x][] 的偏导数表示为：![\\frac\{\\partial f\}\{\\partial x\}][frac_partial f_partial x]，也是![f(x)][f_x]的导数。

要计算![\\frac\{\\partial f\}\{\\partial x\}][frac_partial f_partial x]，必须使y保持固定不变（因此![f][] 现在是只有一个变量的函数），然后取![f][] 相对于![x][]的常规导数。例如，当![y][y 1]固定为1时，前面的函数变为：![f(x) = e^\{2\} sin(x)][f_x_ _ e_2_ sin_x]

这只是一个变量![x][]的函数，其导数为：![e^\{2\} cos(x)][e_2_ cos_x]

一般来说，假设![y][y 1]保持不变，![f][]对![x][]的偏导数的计算公式如下：

![\\frac\{\\partial f\}\{\\partial x\}(x,y) = e^\{2y\}cos(x)][frac_partial f_partial x_x_y_ _ e_2y_cos_x]

同样，如果我们使![x][]保持不变，![f][]对![y][y 1]的偏导数为：

![\\frac\{\\partial f\}\{\\partial x\}(x,y) = 2e^\{2y\}sin(x)][frac_partial f_partial x_x_y_ _ 2e_2y_sin_x]

直观而言，偏导数可以让我们了解到，当略微改动一个变量时，函数会发送多大的变化？在前面的示例中：

![\\frac\{\\partial f\}\{\\partial x\}(0,1) = e^\{2\} \\approx 7.4][frac_partial f_partial x_0_1_ _ e_2_ _approx 7.4]

因此，如果我们将起点设为（0,1），使![y][y 1]保持固定不变，并将![x][]移动一点，![f][]的变化量是![x][]变化量的7.4倍左右。

在机器学习中，偏导数主要与函数的梯度一起使用。

**梯度**

函数的梯度是偏导数相当于所有自变量的矢量，表示为：∇![f][]，诶，CSDN编辑器打不∇

![2021060117424859.png][]

需要注意的是：

<table> 
 <tbody> 
  <tr> 
   <td> <p><strong>∇<img alt="f" src="https://latex.codecogs.com/gif.latex?f"></strong></p> </td> 
   <td>指向函数增长速度最快的方向。</td> 
  </tr> 
  <tr> 
   <td> <p><strong>-∇<img alt="f" src="https://latex.codecogs.com/gif.latex?f"></strong></p> </td> 
   <td>指向函数下降速度最快的方向。</td> 
  </tr> 
 </tbody> 
</table>

该矢量中的维度个数等于![f][]公式中的变量个数；该矢量位于该函数的域空间内。

例如，在三维空间中查看下面的函数![f(x,y)][f_x_y]时：

![20210601175032544.png][]

![z = f(x,y)][z _ f_x_y]就像一个山谷，最低点为（2,0,4）：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 3][]

![f(x,y)][f_x_y]的梯度是一个二维矢量，可让我们了解向那个方向移动时，高度下降得最快；即：梯度矢量指向谷底。

在机器学习中，梯度用于梯度下降法。我们的损失函数通常具有很多变量，而我们尝试通过跟随函数梯度的负方向来尽量降低损失函数。

--------------------

需要注意，梯度是一个矢量，因此具有以下两个特征：

*  方向
 *  大小

梯度始终指向损失函数中增长最为迅猛的方向。梯度下降法会沿着**负梯度**的方向走一步，以便尽快降低损失。梯度下降法依赖于负梯度：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 4][]

为了确定损失函数曲线上的下一个点，梯度下降法会将梯度大小的一部分与起点相加，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 5][]

一个梯度步长将我们移动到损失曲线上的下一个点。然后，梯度下降法会重复此过程，逐渐接近最低点。

## 3.6 关键词-梯度下降法 ##

**梯度下降法**（gradient descent）一种通过计算梯度，并且将损失将至最低的技术，它以训练数据位条件，来计算损失相对于模型参数的梯度。梯度下降法以迭代方式调整参数，逐渐找到权重和偏差的最佳组合，从而将损失降至最低。

参考：[https://developers.google.cn/machine-learning/crash-course/reducing-loss/an-iterative-approach][https_developers.google.cn_machine-learning_crash-course_reducing-loss_an-iterative-approach]

参考：[https://developers.google.cn/machine-learning/crash-course/reducing-loss/gradient-descent][https_developers.google.cn_machine-learning_crash-course_reducing-loss_gradient-descent]

# 四、随机梯度下降、批量梯度下降法 #

## 4.1 前言 ##

在梯度下降法中，批量指的是用于单次迭代中计算梯度的样本总数；即，梯度下降法中批量是指整个数据集。

如果使用大数据集，数据集包含百万级、千万级或亿级的样本；包含海量特征。因此，一个批量可能相当巨大，单次迭代就可能花费很长时间进行计算。

通常，批量大小越大，出现冗余的可能性就越高。一些冗余可能有助于消除杂乱的梯度，但超大批量所具备的预测价值往往并不比大型批量高。

## 4.2 随机梯度下降（SGD） ##

**背景**

梯度下降法在大数据集，会出现费时、价值不高等情况。如果我们可以通过更少的计算量得出正确的平均梯度，效果更好。通过从数据集中随机选择样本，来估算出较大的平均值。

**原理**

它每次迭代只使用一个样本（批量大小为1）。

如果进行足够的迭代，SGD也可以发挥作用，但过程会非常杂乱。“随机”这一术语表示构成各个批量的一个样本都是随机选择的。

## 4.3 批量梯度下降法（BGD） ##

它是介于全批量迭代与随机选择一个迭代的折中方案。全批量迭代（梯度下降法）；随机选择一个迭代（随机梯度下降）。

它从数据集随机选取一部分样本，形成小批量样本，进行迭代。小批量通常包含10-1000个随机选择的样本。BGD可以减少SGD中的杂乱样本数量，但仍然波全批量更高效。

梯度下降、随机梯度下降、批量梯度下降法，三种方法中，通常采用批量梯度下降法类迭代模型。

# 五、学习率 #

## 5.1 前言 ##

梯度矢量具有方向和大小；梯度下降算法用梯度乘以一个称为**学习率**（有时也称为步长）的标量，以确定下一个点的位置。

例如，如果梯度大小为2.5，学习率为0.01，则梯度下降算法会选择距离前一个点0.025的位置作为下一个点。

## 5.2 学习率 ##

**超参数**是编程人员在机器学习算法中用于调整的旋钮。大多数机器学习编程人员会花费相当多的时间来调整学习率。

如果选择的学习率过小，就会花费太长的学习时间：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 6][]

如果选择的学习率过大，下一个点将永远在U形曲线的底部随意弹跳，无法找到全局最低点：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 7][]

如果选择的学习率恰恰好：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 8][]

## 5.3 选择学习率 ##

学习率与损失函数的平坦程度相关。如果知道损失函数的梯度较小，则可以尝试更大的学习率，以补偿较小的梯度并获得更大的步长。

一维空间中的理想学习率是![\\frac\{1\}\{f(x)^\{n\}\}][frac_1_f_x_n]，![f(x)][f_x]对![x][]的二阶导数的倒数。

二维或多维空间中的理想学习率是 Hessian matrix（由二阶偏导数组成的矩阵）的倒数。

广义凸函数的情况则更为复杂。

详细的Hessian matrix参考维基百科： [https://en.wikipedia.org/wiki/Hessian\_matrix][https_en.wikipedia.org_wiki_Hessian_matrix]

## 5.4 关键词 ##

**参数**（parameter），机器学习系统自行训练的模型变量。例如，权重。它们的值是机器学习系统通过连续的训练迭代逐渐学习到的；与超参数相对。

**超参数**（hyperparameter），在模型训练的连续过程中，需要人工指定和调整的；例如学习率；与参数相对。

**学习率**（learning rate），在训练模型时用于梯度下降的一个标量。在每次迭代期间，梯度下降法都会将学习速率与梯度相乘；得出的乘积称为梯度步长。

参考：[https://developers.google.cn/machine-learning/crash-course/reducing-loss/learning-rate][https_developers.google.cn_machine-learning_crash-course_reducing-loss_learning-rate]

# 六、泛化与过拟合 #

## 6.1 前言 ##

本文重点介绍泛化与过拟合模型。

为了能理解泛化这一概念，首先观察3张图。假设这些图中的每个点代表一棵树在森林中的位置。

图中的两种颜色分别代表以下含义：

*  蓝点代表生病的树
 *  橙点代表健康的树

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 1][]

上图中有生病和健康的树，分别对应蓝点、橙点。

需要设计一个模型来区分出那些是生病的树，那些是健康的树。模型的效果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 2][]

表面一看，感觉该模型能很出色地区分出那些是生病的树，那些是健康的树。

实际上该模型有些过拟合了！！

如果用该模型预测一些新数据，效果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 3][]

该模型在处理新数据方面效果很差，对大部分新数据的分类都不正确。

## 6.2 过拟合 ##

**简介**

过拟合模型在训练过程产生的损失很低，但在预测新数据时表现得很差。

**产生原因 **

过拟合是训练数据太小，模型的复杂程度超出所需程度而造成，即：模型结构太过复杂，但任务本来需要表达的规律或含义不需这么复杂。

**机器学习的目标**

机器学习的目标是对真实概率分布中抽取的新数据做出良好的预测；即：对未见过的新数据做出良好预测。

## 6.3 奥卡姆的威廉 ##

奥卡姆的威廉是 14 世纪一位崇尚简单的修士和哲学家。他认为科学家应该优先采用更简单（而非更复杂）的公式或理论。奥卡姆剃刀定律在机器学习方面的运用如下：

> 机器学习模型越简单，良好的实证结果就越有可能不仅仅基于样本的特征。

现今，我们已将奥卡姆剃刀定律正式应用于**统计学习理论**和**计算学习理论**领域。这些领域已经形成了**泛化边界**，即统计化描述模型根据以下因素泛化到新数据的能力：

*  模型的复杂程度
 *  模型在处理训练数据方面的表现

虽然理论分析在理想化假设下可提供正式保证，但在实践中却很难应用。

例如，上面的模型，如果是简单拟合数据，用一根线简单地区分那些是生病的树，那些是健康的树，模型不再过拟合；虽然没有很精准地区分，但大部分的都能区分正确了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 4][]

## 6.4 数据集拆分 ##

机器学习模型旨在根据以前未见过的新数据做出良好预测。但是，如果要根据数据集构建模型，如何获得以前未见过的数据呢？一种方法是将数据集分成两个子集：

*  **训练集** - 用于训练模型的子集。
 *  **测试集** - 用于测试模型的子集。

一般来说，在测试集上表现是否良好是衡量能否在新数据上表现良好的有用指标，前提是：

*  测试集足够大。
 *  不会反复使用相同的测试集来作假。

## 6.5 机器学习--泛化细则 ##

以下三项基本假设阐明了泛化：

*  我们从分布中随机抽取**独立同分布** (**i.i.d**) 的样本。换言之，样本之间不会互相影响。（另一种解释：i.i.d. 是表示变量随机性的一种方式）。
 *  分布是**平稳的**；即分布在数据集内不会发生变化。
 *  我们从**同一分布**的数据划分中抽取样本。

在实践中，我们有时会违背这些假设。例如：

*  想象有一个选择要展示的广告的模型。如果该模型在某种程度上根据用户以前看过的广告选择广告，则会违背 i.i.d. 假设。
 *  想象有一个包含一年零售信息的数据集。用户的购买行为会出现季节性变化，这会违反平稳性。

参考：[https://developers.google.cn/machine-learning/crash-course/generalization/peril-of-overfitting][https_developers.google.cn_machine-learning_crash-course_generalization_peril-of-overfitting]

## 6.6 小结 ##

*  如果某个模型尝试紧密拟合训练数据，但却不能很好地泛化到新数据，就会发生过拟合。
 *  如果不符合监督式机器学习的关键假设，那么我们将失去对新数据进行预测这项能力的重要理论保证。

## 6.7 关键词 ##

**泛化**（generalization），是指模型依据训练时采用的模型，针对未见过的新数据做出争取预测的能力。

**过拟合**（overfitting），创建的模型与训练数据过于匹配，以至于模型无法根据新数据做出正确的预测。

**预测**（perdition），模型在收到数据样本后的输出。

**平稳性**（stationarit），数据集中数据的一种属性，表示数据分布在一个或多个维度保持不变。这种维度最常见的是时间，即：表明平稳性的数据不随时间而变化。

**训练集**（training set），数据集的子集，用于训练模型。与验证集和测试集相对。

**验证集**（validation set），数据集的一个子集，从训练集分离而来，用于调整超参数。与训练集和测试集相对。

**测试集**（test set），数据集的子集，用于在模型经过验证集的初步验证后，进行测试模型。与训练集和验证集相对。

# 七、数据集划分 #

## 7.1 前言 ##

机器学习中可以将数据集分为两个子集，即训练集、测试集。更好的方式是将数据集分为三个子集，即训练集、验证集、测试集。

## 7.2 划分为训练集、测试集 ##

数据集划分为两个子集的概念：

**训练集**—用于训练模型；

**测试集**—用于测试训练后模型

比如，将数据集划分为一个训练集、一个测试集：

![2021060215130618.png][]

使用此方案时，需要确保测试集满足以下两个条件：

*  规模足够大，可产生具有统计意义的结果。
 *  能代表整个数据集。即，挑选的测试集的特征应该与训练集的特征相同。

当测试集满足上述两个条件，通常能得到一个能够较好泛化到新数据的模型。

使用训练集、测试集**训练模型的过程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 5][]

“调整模型”是指调整模型相关的参数、超参数、模型结构，比如：学习率、添加或移除特征，或从小设计全新模型等等。

## 7.3 划分为训练集、验证集、测试集 ##

将数据集划分为三个子集，如下图所示，可以大幅降低过拟合的发送几率：

![20210602175008400.png][]

使用训练集、验证集、测试集**训练模型的过程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 6][]

首先选择早验证集上获得最佳效果的模型。然后使用测试集再次检查该模型。

这个方法训练出来的模型通过会更好，是因为暴露给测试集的信息更少。

> 划分为训练集、验证集、测试集方法中，通过测试集调整模型效果，从中不断学习测试集的规律；从而使得测试集和新数据有区别，模型对测试集有些认识了，对新数据还是完全不认识的情况下预测的

**注意**

不断适应测试集和验证集会使其逐渐失去效果。适应相同数据来决定超参数设置或其它模型改进的次数越多，对于这些结果能够真正泛化到未见过的新数据的效果就越低。

建议：收集更多数据来“刷新”测试集和验证集。重新开始是一种很好的重置方式。

## 7.4 关键词 ##

**训练集**（training set），数据集的子集，用于训练模型。与验证集和测试集相对。

**验证集**（validation set），数据集的一个子集，从训练集分离而来，用于调整超参数。与训练集和测试集相对。

**测试集**（test set），数据集的子集，用于在模型经过验证集的初步验证后，进行测试模型。与训练集和验证集相对。

**过拟合**（overfitting），创建的模型与训练数据过于匹配，以至于模型无法根据新数据做出正确的预测。

参考：[https://developers.google.cn/machine-learning/crash-course/training-and-test-sets/splitting-data][https_developers.google.cn_machine-learning_crash-course_training-and-test-sets_splitting-data]

参考：[https://developers.google.cn/machine-learning/crash-course/validation/another-partition][https_developers.google.cn_machine-learning_crash-course_validation_another-partition]

# 八、特征工程 #

## 8.1 前言 ##

传统编程的关注点是代码。在机器学习项目中，关注点变成了特征表示；即，开发者通过添加和改善特征来调整模型。

> 特征工程是指将原始数据转换为特征矢量；进行特征工程预计需要大量时间。

## 8.2 将原始数据映射到特征 ##

下图中左侧表示来自输入数据源的原始数据，右侧表示特征矢量，也就是组成数据集中样本的浮点值集。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 7][]

特征工程将原始数据映射到机器学习特征。

## 8.3 映射数值 ##

整数和浮点数据不需要特殊编码，因为它们可以与数字权重相乘。

下图中，将原始整数值6转换为特征值6.0并没有多大的意义。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 8][]

## 8.4 映射分类值 ##

分类特征具有一组离散的可能值。例如，可能有一个名为street\_name的特征，其中的选项包括：

{'Charleston Road', 'North Shoreline Boulevard', 'Shorebird Way', 'Rengstorff Avenue'}

由于模型不能将字符串与学习到的权重相乘，因此我们使用特征工程将字符串转为数字值。

**实现思路**

可以定义一个从特征值（称为可能值的词汇表）到整数的映射。

世界上的每条街道并非都会出现在我们的数据集中，因此我们可以将所有其他街道分组为一个全部包罗的“其他”类别，称为OOV分桶（词汇表外）。

**实现过程**

通过上面的方法，我们可以按照以下方式将街道名称映射到数字：

*  将Charleston Road 映射到0
 *  将North Shoreline Boulevard 映射到1
 *  将Shorebird Way 映射到2
 *  将Rengstorff Avenue 映射到3
 *  将所有其他街道（OOV）映射到4

但是，如果我们将这些索引数字直接纳入到模型中，将会造成一些限制：

1）我们将学习适用于所有街道的单一权重。

例如，如果我们学习到street\_name 的权重为6，那么对于Charleston Road，将其乘以0；对于North Shoreline Boulevard 则乘以1；对于Shorebird Way 则乘以2，依次类推。

以某个使用street\_name 作为特征来预测房价的模型为例。根据街道名称对房价进行线性调整的可能性不大，此外，这些假设我们已经根据平均房价对街道怕徐。

我们的模型需要灵活地为每条街道学习不同的权重，这些权重将添加到使用其他特征估算的房价中。

2）我们没有将street\_name 可能有多个值的情况考虑在内。例如，许多房屋位于两条街道的拐角处，因此如果模型包括单个索引，则无法再street\_name 值中对该信息进行编码。

去除以上两个限制，我们可以为模型中的每个分类特征创建一个二元向量来表示这些值：

*  对于使用样本的值，将相应向量元素设为1.
 *  将所有其他元素设为0；

该向量的长度等于词汇表中的元素数。当只有一个值为1 时，这种表示法称为**独热编码**；当有多个值为1时，这种表示法称为**多热编码**。

下图是通过独热编码映射街道地址，为街道Shorebird Way 的**独热编码**。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 9][]

在此二元矢量中，代表Shorebird Way 的元素的值为1，而代表所有其他街道的元素的值为0.

**小结**

该方法能够有效为每个特征值创建布尔变量。采用这种方法时，如果房屋位于Shorebird Way街道上，则只有Shorebird Way的二元值为1.因此，该模型仅使用Shorebird Way 的权重。

如果房屋位于两条街道的拐角处，则将两个二元值设为1，并且模型将使用它们各自的权重。

## 8.5、稀疏表示法 ##

**背景**

假设数据集中有100万个不同的街道名称，您希望将其包含为street\_name 的值。

如果直接创建一个包含100万个元素的二元向量，其中只有1或2个元素为true，则是一种非常低效的表示法，在处理这些向量时会占用大量的存储空间并耗费很长的计算时间。

**简介**

在这种情况下，一种常用的方法是使用稀疏表示法，其中仅存储非零值。在稀疏表示法中，仍然为每个特征值学习独立的模型权重。

## 8.6 良好特征的特点 ##

我们探索了将原始数据映射到适合特征矢量的方法，但这只是工作的一部分。然后需要探索什么样的值才算这些特征矢量中良好的特征。

*  避免很少实用的离散特征值
 *  最好具有清晰明确的含义
 *  实际数据内不要掺入特殊值
 *  考虑上游不稳定性

**5.1）避免很少使用的离散特征值**

良好的特征值应该在数据集中出现大约5次以上。这样一来，模型就可以学习该特征值与标签是如何关联的。大量离散值相同的样本可让模型有机会了解不同设置中的特征，从而判断何时可以对标签很好地做出预测。例如，house\_type特征包含大量样本，其中它的值为victorian:

house_type: victorian

如果某个特征值仅出现一次火灾很少出现，则模型就无法根据该特征进行预测。例如，unique\_house\_id 就不适合作为特征，因为每个值只使用一次，模型无法从中学习任何规律：

unique_house_id: 8SK982ZZ1242Z

**5.2）最好具有清晰明确的含义**

每个特征对于项目中的任何人，来说都应该具有清晰明确的含义。例如，房龄适合作为特征，可立即识别是以年为单位的房龄：house\_age: 27

相反，对于一些特征值的含义，除了创建它的工程师，其他人恐怕辨识不出：house\_age: 851472000

在某些情况下，混乱的数据会导致含义不清晰的值。例如，user\_age的来源没有检查值是正确：user\_age: 277

**5.3）实际数据内不要掺入特殊值**

良好的浮点特征不包含超出范围的异常断点或特征的值。例如，假设一个特征具有0到1 之间的浮点值。那么，如下值是可以接受的：

quality_rating: 0.82
    quality_rating: 0.37

不过，如果用户没有输入quality\_rating，则数据集可能使用如下特殊值来表示不存在该值：

quality_rating: -1

为了解决特殊值的问题，需将该特征转换为两个特征：

*  一个特征只存储质量评分，不含特殊值。
 *  一个特征存储布尔值，表示是否提供了quality\_rating。

**5.4）考虑上游不稳定性**

特征的定义不应随时间变化。例如，下列值是有用的，因为城市名称一般不会改变。

city_id: "br/sao_paulo"

但收集由其他模型推理的值会产生额外成本。可能值“219”目前代表圣保罗，但这种表示在未来运行其他模型时可能轻易发送变化：

inferred_city_cluster: "219"

## 8.7 关键词 ##

**特征工程**（feature engineering），是指确定哪些特征可能在训练模型方面非常有用，然后将日志文件及其他来源的原始数据转换为所需的特征。特征工程有时称为特征提取。

**离散特征**（discrete feature），一种特征，包含有限个可能值。例如，某个值只能是“动物”、或“蔬菜”的特征，这是都能将类别列举出来的。与连续特征相对。

**独热编码**（one-hot-encoding），一种稀疏二元向量，其中：

*  一个元素设为1.
 *  其他所有元素均设为0 。

独热编码常用语表示拥有 有限个可能值的字符串或标识符。

**表示法**（representation），将数据映射到实用特征的过程。

参考：[https://developers.google.cn/machine-learning/crash-course/representation/feature-engineering][https_developers.google.cn_machine-learning_crash-course_representation_feature-engineering]

参考：[https://developers.google.cn/machine-learning/crash-course/representation/qualities-of-good-features][https_developers.google.cn_machine-learning_crash-course_representation_qualities-of-good-features]

# 九、正则化L2（简单性） #

## 9.1 前言 ##

通过降低模型复杂度来防止过拟合，这种原则称为**正则化**。

## 9.2 原理 ##

训练模型时，并非只是以最小损失（经验风险最小化）为目的

![minimize(Loss(Data|Model))][minimize_Loss_Data_Model]

而是以最小化损失和复杂度为目标，这称为结构风险最小化：

![minimize( Loss (Data | Model) + complexity(Model))][minimize_ Loss _Data _ Model_ _ complexity_Model]

现在，我们的训练优化算法是一个由两项内容组成的函数：

*  一个是损失项，用于衡量模型与数据的拟合度；
 *  另一个是正则化项，用于衡量模型复杂度。

## 9.3 复杂度 ##

常见的两种衡量模型复杂度的常见方式：

*  将模型复杂度作为模型中所有特征权重的函数。
 *  将模型复杂度作为具有非零权重的特征总数的函数。

如果模型复杂度是权重的函数，则特征权重的绝对值越高，对模型复杂度的贡献就越大。

## 9.4 L2正则化 ##

我们可以使用![L\_\{2\}][L_2]正则化公式来量化复杂度，该公式将正则化项定义为**所有特征权重的平方和**：

![L\_\{2\} regularization term = \\left \\| w \\right \\|\_\{2\}^\{2\} = w\_\{1\}^\{2\} +w\_\{2\}^\{2\}+.....+w\_\{n\}^\{2\}][L_2_ regularization term _ _left _ w _right _2_2_ _ w_1_2_ _w_2_2_....._w_n_2]

这个公式中，接近于0的权重对模型复杂度几乎没有影响，而离群值权重则会肯呢个产生巨大的影响。

例子，某个线性模型具有以下：

![\{w\_\{1\} = 0.2, w\_\{2\} = 0.5, w\_\{3\} = 5, w\_\{4\} = 1, w\_\{5\} = 0.25, w\_\{6\} = 0.75\}][w_1_ _ 0.2_ w_2_ _ 0.5_ w_3_ _ 5_ w_4_ _ 1_ w_5_ _ 0.25_ w_6_ _ 0.75]

结合公式，计算得 ![L\_\{2\}][L_2]正则化项为26.915:

![w\_\{1\}^\{2\} + w\_\{2\}^\{2\} + w\_\{3\}^\{2\} + w\_\{4\}^\{2\} + w\_\{5\}^\{2\} +w\_\{6\}^\{2\} = 0.2^\{2\} + 0.5^\{2\} + 5^\{2\} + 1^\{2\} +0.25^\{2\} +0.75^\{2\}][w_1_2_ _ w_2_2_ _ w_3_2_ _ w_4_2_ _ w_5_2_ _w_6_2_ _ 0.2_2_ _ 0.5_2_ _ 5_2_ _ 1_2_ _0.25_2_ _0.75_2]

![=0.04 + 0.25 + 25 + 1 + 0.0625 + 0.5625 = 26.915][0.04 _ 0.25 _ 25 _ 1 _ 0.0625 _ 0.5625 _ 26.915]

上面的案例中![w\_\{3\}][w_3]的平方值为25，几乎贡献了全部的复杂度。其他5个权重的平方和的值仅为1.915，在![L\_\{2\}][L_2]正则化项的贡献小。所以， ![L\_\{2\}][L_2]正则化项，**接近于0的权重对模型复杂度几乎没有影响，而离群值权重则会肯呢个产生巨大的影响**。

## 9.5 简化正则化：Lambda ##

模型开发者通过以下方式来调整正则化项的整体影响：用正化项的值乘以名为**lambda**（又称为正则化率）的标量。模型开发者会执行以下运行：

![minimize(Loss(Data|Model)) + \\lambda complexity(Model))][minimize_Loss_Data_Model_ _ _lambda complexity_Model]

其中![\\lambda][lambda]是指lambda；

执行![L\_\{2\}][L_2]正则化对模型具有以下影响

*  使权重值接近于0（但并非正好为0）
 *  使权重的平均值接近于0，且呈现正态分布（高斯曲线）

添加lambda值将增强正则化效果。例如，lambda值较高的权重直方图可能如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 10][]

如果降低lambda的值往往会得出比较平缓的直方图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 11][]

在选择lambda值时，目标是在简单化和训练数据拟合之间达到适当的平衡：

*  如果lambda值过高，则模型会非常简单，面临数据欠拟合的风险；模型将无法从训练数据中获得足够的信息来做出有用的预测。
 *  如果lambda值过低，则模型会比较复杂，并且面临数据过拟合的风险；模型因获得过多训练数据特征方面的信息，而无法泛化到新数据。

> **注意：**
> 
> 将lambda设为0可彻底取消正则化。这种情况下，训练的唯一目的是最小化损失，而这样做会使得过拟合的风险达到最高。

理想的lambda值生成的模型可以很好地泛化到之前没有见过的新数据；通常，理想的lambda值取决于数据，需要手动或自动进行一些调整。

## 9.6 ![L\_\{2\}][L_2]正则化和学习率 ##

学习率和lambda之间存在密切关联。

强 ![L\_\{2\}][L_2]正则化值往往会使得特征权重更接近于0。较低的学习率（使用早停法）通常会产生相同的效果。因此，同时调整学习率和lambda可能会产生令人混淆的效果。

**早停法**是指模型完全收敛之前就结束训练。在实际操作中，我们经常在以连续方式进行训练，采取一些隐式早停法。

如上所述，更改正则化参数产生的效果，可能会与更改学习率或迭代次数产生的效果混淆。有一种方式，在训练一批固定的数据时，执行足够多次迭代，这样早停法便不会起作用。

参考：[https://developers.google.cn/machine-learning/crash-course/regularization-for-simplicity/l2-regularization][https_developers.google.cn_machine-learning_crash-course_regularization-for-simplicity_l2-regularization]

参考：[https://developers.google.cn/machine-learning/crash-course/regularization-for-simplicity/lambda][https_developers.google.cn_machine-learning_crash-course_regularization-for-simplicity_lambda]

# 十、逻辑回归、线性回归 #

## 10.1 前言 ##

许多问题需要将概率估算值作为输出。逻辑回归是一种极其高效的概率计算机制。

## 10.2 计算并返回概率的方式 ##

*  按原样
 *  转换成二元类别

**按原样**使用概率；假设我们创建一个逻辑回归模型来预测狗在半夜发出叫声的概率。我们将此概率称为：![p(bark | night)][p_bark _ night]

如果逻辑回归模型预测![p(bark | night)][p_bark _ night]的值为0.05，那么一年内（365天），主人被狗惊醒约18次：

![started = p (bark | night) \* nights][started _ p _bark _ night_ _ nights]  即：18 = 0.05 \* 365

**转换为二元类别**

在很多情况下，将逻辑回归输出映射到二元分类问题的解决方案，该二元分类问题的目标是正确预测两个可能的标签中的一个。

## 10.3 S形函数 ##

逻辑回归模型如何确保输出值始终落在0和1之间呢？S型函数生成的输出值正好具有这些特征，其定义如下：

![y = \\frac\{1\}\{1+e^\{-z\}\}][y _ _frac_1_1_e_-z]

S型函数会产生以下曲线：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 12][]

如果z表示使用逻辑回归训练的模型的线性层的输出，则S型函数会生成一个介于0和1之间的值（概率）。用数学方法表示为：

![y^\{'\}=\\frac\{1\}\{1+e^\{-(z)\}\}][y_frac_1_1_e_-_z]

其中：

*  ![y^\{'\}][y]是逻辑回归模型针对特定样本的输出。
 *  z是![b+w\_\{1\}x\_\{1 \}+ w\_\{2\}x\_\{2 \} +......+ w\_\{N\}x\_\{N \}][b_w_1_x_1 _ w_2_x_2 _ _......_ w_N_x_N]；w是该模型学习的权重，b是偏差。x是指特征样本的特征值。

请注意，z也称为对数几率，因为S型函数的反函数表明：z可定义为标签“1”的概率除以标签“0”的概率，得出的值的对数：

![z = log(\\frac\{y\}\{1-y\})][z _ log_frac_y_1-y]

以下是具有机器学习标签的S型函数：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 13][]

## 10.4 逻辑回归推断计算 ##

假设我们的逻辑回归模型具有学习了下列偏差和权重的三个特征：

*  b = 1
 *  w1 = 2
 *  w2 = -1
 *  w3 = 5

进一步假设给定样本具有以下特征：

*  x1 = 0
 *  x2 = 10
 *  x3 =2

因此，对数几率：![b + w\_\{1\}x\_\{1\} + w\_\{2\}x\_\{2\} + w\_\{3\}x\_\{3\}][b _ w_1_x_1_ _ w_2_x_2_ _ w_3_x_3]

代入公式计算得：（1）+（2)(0）+（-1)(10）+（5)(2）=1

因此，此特定样本的逻辑回归预测值将是0.731：

![y^\{'\}=\\frac\{1\}\{1+e^\{-(1)\}\}=0.731][y_frac_1_1_e_-_1_0.731]

概率输出为0,731，即73.1%的概率：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 14][]

## 10.5 逻辑回归的损失函数 ##

线性回归的损失函数是平方损失。逻辑回归的损失函数是对数损失函数，定义如下：

![LohLoss =\\sum\_\{(x,y)\\epsilon D\}^\{\} - ylog(y^\{'\}) - (1-y)log(1-y^\{'\})][LohLoss _sum_x_y_epsilon D_ - ylog_y_ - _1-y_log_1-y]

其中：

*  ![(x,y)\\epsilon D][x_y_epsilon D]是包含很多有标签样本（x，y）的数据集。
 *  y是有标签样本的标签。由于这是逻辑回归，因此y的每个值都必须使0或1.
 *  ![y^\{'\}][y]是对于特征集x的预测值（介于0和1之间）。

对数损失函数的方程式，是似然函数的负对数。

## 10.6 逻辑回归中的正则化 ##

正则化在逻辑回归建模中极其重要。如果没有正则化，逻辑回归的逐渐性会不断促使损失在搞维度空间内达到0.因此，大多数逻辑回归模型会使用一下两个策略之一来降低模型复杂性：

*  ![L\_\{2\}][L_2]正则化。
 *  早停法，即：限制训练步数或学习率。

假设向每个样本分配一个唯一ID，且将每个ID映射到其自己的特征。如果未指定正则化函数，模型会变得完成过拟合。

这是因为模型会尝试促使所有样本的始终损失达不到0，从而使每个特征的权重接近正无穷或负无穷。当大量罕见的特征组合的高纬度数据就会出现这种情况。![L\_\{2\}][L_2]正则化或早停法可以防止此类问题。

## 10.7 逻辑回归小结 ##

逻辑回归模型生成概率。

对数损失函数使逻辑回归的损失函数。

逻辑回归被很多从业者广发使用。

### 10.8 线性回归 ###

本案例观察蟋蟀鸣叫的规律，训练一个模型，预测鸣叫与温度的关系。

蟋蟀在较为炎热的天气里鸣叫更为频繁，数十年来，专业和业余昆虫学者已将每分钟的喵叫和温度方面的数据编入目录。

温度与蟋蟀鸣叫的数据，先了解数据的分布情况：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 15][]

上图表示每分钟的鸣叫与温度的关系。

此曲线图中能看到随着温度的升，蟋蟀鸣叫次数特增加。鸣叫声与温度之间的关系是线性关系。

可以绘制一条直线来近视地表示这种关系，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 16][]

虽然图中的每个点不是完全分布在直线上，但基本都在直线附近；线性关系用公式表示如下：

![y = mx + b][y _ mx _ b]

其中：

*  y是指温度，是预测的值；
 *  m是指直线的斜率；
 *  x是指每分钟的鸣叫声次数，即输入特征的值。
 *  b是指y轴截距。

按照机器学习的方式，写一个模型方程式：

![y^\{'\} = b + w\_\{1\} x\_\{1\}][y_ _ b _ w_1_ x_1]

其中：

*  ![y^\{'\}][y]是指预测的标签（输出值）
 *  b是指偏差（对应y轴截距），一些机器学习文档中，称为![w\_\{0\}][w_0]
 *  ![w1][]是指特征1的权重。权重与上文中用m表示“斜率”的概念相同。
 *  ![x\_\{1\}][x_1]是指特征。（输出向）

要根据新的每分钟的鸣叫声值![x\_\{1\}][x_1]推断（预测）温度![y^\{'\}][y]，只需将![x\_\{1\}][x_1]值代入此模型即可。

下标（例如![w1][]和![x\_\{1\}][x_1]）预示着可以用多个特征来表示更复杂的模型。例如，具有三个特征的模型可以采用以下方程式：

![y^\{'\} = b + w\_\{1\}x\_\{1\} + w\_\{2\}x\_\{2\} + w\_\{3\}x\_\{3\}][y_ _ b _ w_1_x_1_ _ w_2_x_2_ _ w_3_x_3]

参考：[https://developers.google.cn/machine-learning/crash-course/descending-into-ml/linear-regression][https_developers.google.cn_machine-learning_crash-course_descending-into-ml_linear-regression]

**关键词**

**偏差**（bias），距离原点的截距或偏移。偏差（也称为偏差项）在机器学习模型中用b或![w\_\{0\}][w_0]表示。例如，在下面的公式中，偏差为b：![y^\{'\} = b + w\_\{1\} x\_\{1\} +w\_\{2\} x\_\{2\} +.......w\_\{n\} x\_\{n\}][y_ _ b _ w_1_ x_1_ _w_2_ x_2_ _.......w_n_ x_n]

**推断**（inference），在机器学习中，推断通常指以下过程：通过将训练过的模型应用于无标签样本来做出雨雪。在统计学中，推断是指在某些观察数据条件下拟合分布参数的过程。（请参阅[维基百科中有关统计学推断的文章][Link 2]。）

**线性回归**（linear regression），一种回归模型，通过将输入特征进行线性组合输出连续值。

**权重**（weight），模型中特征的系数，或深度网络中的边。训练模型的目标是确定每个特征的理想权重。如果权重为0，则相应的特征对模型来说没有任何影响。

参考：[https://developers.google.cn/machine-learning/crash-course/logistic-regression/calculating-a-probability][https_developers.google.cn_machine-learning_crash-course_logistic-regression_calculating-a-probability]

参考：[https://developers.google.cn/machine-learning/crash-course/logistic-regression/model-training][https_developers.google.cn_machine-learning_crash-course_logistic-regression_model-training]

# 十一、正则化L1（稀疏性） #

## 11.1 前言 ##

![L\_\{1\}][L_1]正则化，也称稀疏性正则化。

创建特征组合会导致包含更多维度；由于使用此类高纬度特征矢量，因此模型可能会非常庞大，并且需要大量的RAM。

## 11.2 稀疏性的正则化 ##

在高纬度稀疏矢量中，最好尽可能使权重正好降至0。正好为0的权重基本会使相应特征从模型中移除。将特征设为0可节省RAM空间，且可以减少模型中的噪点。

**L1正则化（L1 regularization）**，一种正则化，根据权重的绝对值的总和来惩罚权重。在以来稀疏特征的模型中，L1正则化有助于使不相关或几乎不相关的特征的权重正好为0，从而将这些特征从模型中移除。与L2正则化相对。

> 对比：![L\_\{2\}][L_2]正则化可以使权重变小，但是并不能使它们正好为0.0。

## 11.3 ![L\_\{1\}][L_1]和![L\_\{2\}][L_2]正则化对比 ##

![L\_\{1\}][L_1]和![L\_\{2\}][L_2] 采用不同的方式降低权重：

*  ![L\_\{1\}][L_1]采用绝对值的方式降低权重，即![\\left | w \\right |][left _ w _right]
 *   ![L\_\{2\}][L_2]采用平方的方式降低权重的，即![w^\{2\}][w_2]

因此， ![L\_\{1\}][L_1]和![L\_\{2\}][L_2] 具有不同的导数：

*  ![L\_\{1\}][L_1]的导数为k（一个常数，其值与权重无关）。
 *  ![L\_\{2\}][L_2]的导数为2\*权重。

![L\_\{1\}][L_1]导数的作用理解为：每次从权重中减去一个常数。不过，由于减去的是绝对值，![L\_\{1\}][L_1]在0处具有不连续性，这会导致与0相交的减法结果变为0。例如，如果减法使权重从+0.1变为-0.2，![L\_\{1\}][L_1]便会将权重设为0。就这样，![L\_\{1\}][L_1]使权重变为0了。

![L\_\{2\}][L_2]的导数作用理解为：每次移除权重的x%。对于任意数字，即使按每次减去x%的幅度执行数十亿次减法计算，最后得出的值也绝不会正好为0。即，![L\_\{2\}][L_2]通常不会使权重变为0。

**小结**：![L\_\{1\}][L_1]正则化，减少所有权重的绝对值，对宽度模型非常有效。

下面是比较 L1 和 L2 正则化对权重网络的影响：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 17][]

能看到L1正则化会把很小的权重变为0；

## 11.4 关键词 ##

**L1正则化**（L1 regularization），一种正则化，根据权重的绝对值的总和，来惩罚权重。在以来稀疏特征的模型中，L1正则化有助于使不相关或几乎不相关的特征的权重正好为0，从而将这些特征从模型中移除。与L2正则化相对。

**L2正则化**（L2 regularization），一种正则化，根据权重的平方和，来惩罚权重。L2正则化有助于使离群值（具有较大正值或较小负责）权重接近于0，但又不正好为0。在线性模型中，L2正则化始终可以进行泛化。

参考：[https://developers.google.cn/machine-learning/crash-course/regularization-for-sparsity/l1-regularization][https_developers.google.cn_machine-learning_crash-course_regularization-for-sparsity_l1-regularization]

# 十二、神经网络 #

## 12.1 前言 ##

本文主要介绍神经网络。有些分类问题是属于非线性问题：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 18][]

“非线性”意味着无法使用这样的形式：![b +w\_\{1\}x\_\{1\} + w\_\{2\}x\_\{2\}][b _w_1_x_1_ _ w_2_x_2] 的模型精准预测标签。即：“决策面”不是直线。

如果数据集如下所示（更难的非线性分类问题）：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 19][]

上图的数据集问题，无法使用线性模型解决。

## 12.2 非线性问题解决方法 ##

或者可以考虑一个可行方法，对非线性问题进行建模——特征组合。

或者使用神经网络解决非线性问题，通常效果较好；它不一定始终比特征组合好，但它确实可以提供适用于很多情形的灵活代替方案。

## 12.3 单层神经网络 ##

单层神经网络，其实也是一个线性模型，模型结构如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 20][]

每个蓝色圆圈均表示一个输入特征，绿色圆圈表示各个输入的加权和。

这里明明有输出层、输出层，为什么叫单层神经网络呢？

通常，统计神经网络层数时，对有权重参数的层，才进行统计。输入层只负责特征数据输入，没有参数，所以不纳入统计层数的。

## 12.4 两层神经网络 ##

在输入层和输出层之间，添加多一层网络，其称为隐藏层。如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 21][]

隐藏层中的每个黄色节点均是，蓝色输入节点值的加权和。输出时黄色节点的加权和。

两层神经网络，其输出仍是其输入的线性组合。

## 12.5 三层神经网络 ##

由输出层、隐藏层1、隐藏层2、输出层组成；在输入层和输出层之间的都可以称为隐藏层。：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 22][]

此模型仍是线性的；当将输出表示为输入的函数并进行简化时，只是获得输入的另一个加权和而已。

该加权和无法对非线性问题，进行有效建模。

## 12.6 激活函数 ##

要对非线性问题进行建模，我们可以直接引入非线性函数。我们可以使用非线性函数将每个隐藏节点享管道一样连接起来。

在下图所示的模型中，在隐藏层1中各个节点的只传递到一下层，进行加权求和之前；我们采用一个非线性函数对其进行了转换。这种非线性函数成为激活函数。

包含激活函数的三层模型：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 23][]

现在，我们已经添加了激活函数，如果添加层，将会产生更多影响。通过在非线性上堆叠非线性，我们能够对输入和预测输出之间极其复杂的关系进行建模。

每一层均可通过原始输入有效学习更复杂、更高级别的函数。

**常见激活函数**

1、S型激活函数，将加权和转换为介于0和1之间的值。

![F(x)=\\frac\{1\}\{1+e^\{-x\}\}][F_x_frac_1_1_e_-x]

曲线图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 24][]

2、修正线性单元激光函数，简称ReLU，相对于S型函数等平滑函数，它的效果通常要好一点，同时还非常易于计算。

![F(x)=max(0,x)][F_x_max_0_x]

ReLU的优势在于它基于实证发现，拥有更实用的响应范围。S型函数的响应性在两端相对较快地减少。ReLU激活函数如下所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 25][]

实际上，所有数学函数均可作为激光函数。假设![\\sigma][sigma]表示我们的激活函数（ReLuck、S型函数等等）。因此，网络中节点的值由以下公式指定：

![\\sigma (w\\cdot x+b)][sigma _w_cdot x_b]

## 12.7 总结 ##

现在，我们的模型拥有了人们通常所说的“神经网络”的所有标准组件：

*  一组节点，类似于神经元，位于层中。
 *  一组权重，表示每个神经网络层与下方的层之间的关系。下方的层可能是另一个神经网络层，也可能是其他类型的层。
 *  一组偏差，每个节点一个偏差。
 *  一个激活函数，对层中每个节点的输出进行转换。不同的层可能拥有不同的激光函数。

参考：[https://developers.google.cn/machine-learning/crash-course/introduction-to-neural-networks/anatomy][https_developers.google.cn_machine-learning_crash-course_introduction-to-neural-networks_anatomy]

# 十三、 嵌入Embedding #

## 13.1 协同过滤 ##

协同过滤是一项可以预测用户兴趣的任务。一影片推荐的任务为例，假设有100万个用户，以及每位用户观看过的列表，其中可供观看的影片共有50万部。目标是向用户推荐影片。

要解决这个问题，我们需要使用某种方法来确定哪些影片是相似的。我们可以通过将影片嵌套到低维空间，是的相似的影片彼此邻近，俩实现这个目标。

在介绍如果学习嵌套之前，我们先来了解一下，我们希望嵌套具备的特质类型，以及我们将如何表示训练数据以供学习嵌套。

**在一维数轴上排列影片**

为了更直观地了解嵌套过程，下面列举了一些数据；试着在一维数轴上排列以下影片，让越相关的影片考得越近。

<table> 
 <thead> 
  <tr> 
   <th>影片</th> 
   <th><a href="https://wikipedia.org/wiki/Motion_Picture_Association_of_America_film_rating_system#MPAA_film_ratings" rel="nofollow">分级</a></th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt0108394/" rel="nofollow">《蓝》</a></td> 
   <td>R</td> 
   <td>一位法国妇人在丈夫与爱女丧命于一场车祸后悲痛欲绝。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt1345836" rel="nofollow">《蝙蝠侠：黑暗骑士崛起》</a></td> 
   <td>PG-13</td> 
   <td>这部影片是<a href="http://www.imdb.com/title/tt0468569/" rel="nofollow">《黑暗骑士》</a>的续集，以 DC 漫画的宇宙空间为背景，讲述蝙蝠侠尽力保护高谭市免遭核毁灭的故事。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt0241527/" rel="nofollow">《哈利·波特与魔法石》</a></td> 
   <td>PG</td> 
   <td>一个失去双亲的男孩发现自己会巫术，于是前去霍格沃茨魔法学校学习魔法，在这里他与邪恶的伏地魔展开了第一场激斗。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt0317705/" rel="nofollow">《超人总动员》</a></td> 
   <td>PG</td> 
   <td>被迫在郊区过着平民生活的超人一家重出江湖，拯救超人家族免遭辛拉登及其杀手机器人的迫害。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt0126029/" rel="nofollow">《怪物史莱克》</a></td> 
   <td>PG</td> 
   <td>可爱的怪物史莱克和他的伙伴驴子，启程营救被火龙囚禁在城堡的菲奥娜公主。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt0076759" rel="nofollow">《星球大战》</a></td> 
   <td>PG</td> 
   <td>卢克·天行者和汉·索洛与两个义军机器人结成一队，共同拯救莱娅公主并保卫星球。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt0286244" rel="nofollow">《疯狂约会美丽都》</a></td> 
   <td>PG-13</td> 
   <td>专业骑行者查宾在环法自行车大赛期间被挟持，他的奶奶带着他家的胖狗漂洋过海，并在爵士歌手三姐妹的帮助下救出了他。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.imdb.com/title/tt0209144/" rel="nofollow">《记忆碎片》</a></td> 
   <td>R</td> 
   <td>一位短期记忆丧失症患者将线索纹在身上，竭尽全力寻找杀害自己妻子的凶手。</td> 
  </tr> 
 </tbody> 
</table>

一个可行（但极不完善）的解决方案：把所以影片一行排列

![20210610110815389.png][]

虽然中嵌套有助于捕获影片的适宜观赏年龄段，但在推荐影片时还需要考虑影片的许多其它方面。我们进一步分析此示例，在添加一个嵌套维度。

**在二维空间中排列影片**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 26][]

使用这种二维嵌套，我们可以定义影片之间的距离，从而是得在适宜儿童或成人的相近程度上影片，以及属于大片或艺术影片的程度上相近的影片，位于相近的位置。当然，这是影片诸多重要特征中的两个。

简单来说，我们所做的是将这些影片映射到一个嵌套空间，其中的每个字词都有一组二维坐标来表示。例如，在这个空间中，《怪物史菜克》映射到了（-1.0 , 0.95）；而《蓝》映射到了（0.65 ， -0.2）。

通常情况下，在学习d维嵌套时，每部影片都由d个实值数字表示，其中每个数字都分别表示在一个维度中的坐标。

--------------------

在此示例中，我们为每个维度指定了名称。在学习嵌套时，每个维度的学习跟它们的名字无法。有时我们可以查看嵌套并为维度赋予语义，但有时则无法做到这一点。

通常，每个此类维度都称为一个**潜在维度**，因为它代表的特征没有明确显示在数据中，而是需要根据数据推断得出。

最终，真正有意义的是嵌套空间中各个影片之间的距离，而不是单个影片在任意指定维度上的坐标。

参考：[https://developers.google.cn/machine-learning/crash-course/embeddings/motivation-from-collaborative-filtering][https_developers.google.cn_machine-learning_crash-course_embeddings_motivation-from-collaborative-filtering]

## 13.2 分类输入数据 ##

分类数据是指用于表示一组有限选项中的，一个或多个离散项的输入特征。例如，它可以是某用户观看过的一组影片，某文档中使用的一系列单词，或某人从事的职业。

分类数据的最高效表示方式是使用**稀疏张量**（一种含有极少非零元素的张量）。例如，如果要构建一个影片推荐模型，可以为每部的影片分别分配一个唯一的ID，然后通过用户已观看影片的稀疏张量来表示每位用户，如图下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 27][]

在上图中，每行都是一个样本，这个样本显示用户的影片观看记录；上图以稀疏张量的形式表示，因为每个用户只会观看所有可能的影片中的一小部分。

根据影片图标上方所示的索引，最后一行对应于稀疏张量\[1,3,999999\]。

> 类似地，我们还可以将字词、句子和文档表示为稀疏矢量；在这种情况下，词汇表内每个字词所扮演的角色类似于推荐示例中的影片。

## 13.3 稀疏矢量 表示为 数字矢量 ##

为了能够在机器学习系统中使用这类表示法，我们需要将每个稀疏矢量表示为数字矢量，从而使语义上相识的项（影片或字词），在矢量空间中具有相似的距离。

但如何将字词的稀疏矢量表示为数字矢量呢？

最简单的方法是：

【1】定义一个巨型输入层，并在其中为词汇表的每个字词设定一个节点，或者只是为数据中出现的每个字词设定一个节点。

如果我们的数据中出现了50万个独一无二的单词，可以使用长度为50万的矢量来表示每个单词，将每个字词分配到相应矢量中对应的索引位置。

如果为“马”分配的索引是1247，当“马”输入到网络中，可以将第1247个输入节点设成1，其余节点设成0。这种表示法称为独热编码（one-hot encodering），因为只有一个索引具有非零值。

【2】更常见的是，使用一个包含各个单词在大块文本中出现次数的向量。这杯称为“词袋”（bag of words）表示法。在一个词袋矢量中，50万个节点中的若干个节点将具有非零值。

不过，无论我们如何确定非零值，若将节点与字词一一对应，我们得到的输入矢量就会比较稀疏：矢量很大，但非零值相对较少。

## 13.4 稀疏表示法存在的问题 ##

稀疏表示法会使模型很难高效地学习。

### 13.4.1 网络规模 ###

巨型输入矢量意味着神经网络的对应权重数目会机器庞大。

如果我们的词汇表找那个有M个字词，而神经网络输入层上方的第一层有N个节点，需要为该层训练MxN个权重。权重数目过大会进一步引发以下问题：

*  **数据量**：模型中的权重越多，高效训练所需的数据就越多。
 *  **计算量**：权重越多，训练和使用模型所需的计算就越多。这很容易就会超出硬件的能力范围。

### 13.4.2 矢量之间缺乏有用意义的联系 ###

如果将RGB通道的像素值输入到图片分类器中，分析“邻近”值是可行的。不过是从语义上来看，还是从矢量之间的几何距离来看，红蓝色与纯蓝色都是邻近对的。

不过，对于在索引1247处设为1，来表示“马”的矢量而言；如果说它在索引238处设为1，来表示“电视机”的矢量不够邻近；那么它与在索引50430处设为1，来说表示“羚羊”的矢量依然。

### 13.4.3 解决方案：嵌套 ###

上述问题的解决方案是使用嵌套，也就是将大型**稀疏矢量映射**到一个**保留语义关系的低维空间**。

## 13.5、转换到低维空间 ##

**背景**

要解决稀疏输入数据的核心问题，我们可以将高维度数据映射待低维度空间。

**分析**

即便是小型多维空间，也能自由地将语义上相似的项归到一起，并将相异项分开。

矢量空间中的位置（距离和方向）可以良好的嵌套中的语义进行编码。

例如，下面的真实嵌套可视化图展示的几何关系图捕获了国家与首都之间的语义关系。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 28][]

嵌套可以产生精彩的模拟；借助这种有意义的空间，机器学习系统能够检测出对学习任务可能有帮助的模式。

**收缩网络**

尽管我们需要足够的维度来编码丰富的语义关系，但我们也需要足够小的嵌套空间来更快速地训练我们的系统。

使用嵌套的量级大致有数百个维度，这可能比我们在自然语言任务中使用的词汇规模要小好几个数量级。

**嵌套充当查询表**

嵌套是一个矩阵，每列表示我们词汇中一项所对应的矢量。要获得某个词汇项的密集矢量，可以检索该项所对应的列。

但是，如何转换字词矢量的稀疏包呢？

要获得表示多个词汇项；例如，一句或一段中的所有字词，的稀疏矢量的密集矢量，可以检索各项的嵌套，然后将它们相加。

稀疏矢量包含词汇项的计数？

如果稀疏矢量包含词汇项的计数，则可以将每项嵌套与其对应项的计算相乘，然后再求和。

**嵌套查询充当矩阵乘法**

查询、乘法和加法程序等效于矩阵乘法。假设有一个1xN的稀疏表示S和一个NxM的嵌套表E，矩阵乘法SxE可以得出密集矢量1xM。

但如果获取E呢？下一节介绍如何获取嵌套。

参考：[https://developers.google.cn/machine-learning/crash-course/embeddings/translating-to-a-lower-dimensional-space][https_developers.google.cn_machine-learning_crash-course_embeddings_translating-to-a-lower-dimensional-space]

## 13.6、获取嵌套 ##

我们可以通过多种方式来获取嵌套，包括Google研发的一流算法。

### 13.6.1 标准降维技术 ###

目前有很多在低维空间 捕获 高维空间重要结构 的数学技术。理论上，这些技术都可以用来创建于机器学习系统的嵌套。

例如，主成分分析（PCA）已用于创建字词嵌套。在给定一组实例的情况下，例如字词矢量包，PCA会尝试查找高度相关且可以合并的维度。

### 13.6.2 Word2vec ###

**简介**

Word2Vec 是 Google 为了**训练字词嵌套**而研发的一种算法。

**原理**

Word2vec基于分布假设，将语义上相似的字词 映射到 几何图形上邻近的嵌套矢量。

**分布假设**，是指经常具有相同邻字词的字词，往往在语义上相似。简单来说，就是分布相互邻近的字词，往往语义也相似。

例如，“狗”和“猫”这两个词经常靠近“兽医”一词，这就可以说明这两个字词在语义上相似。

**结构**

Word2Vec 通过训练神经网络来区分，实际共同出现的多组字词与随机出现在一起的字词，从而充分利用此类上下文信息。

输入层采用一种稀疏表示法用于，组合一个目标字词 与一个或多个上下文字词。这一输入层会连接到一个较小的隐藏层。

在训练模型后，我们得到的是一组嵌套，借助将输入层连接到隐藏层的权重；可以将字词的稀疏表示映射到小型矢量。这类嵌套可在其他分类中重复使用。

### 13.6.3 将嵌套训练 作为 大型模型的一部分 ###

**简介**

我们可以将 嵌套 作为目标任务的神经网络的一部分，然后进行学习训练。通过这个方法，可以为自己的特定系统量身定制嵌套，不过耗费的时间可能比单独训练嵌套的时间长。

**应用**

一般来说，当我们有稀疏数据时，可以创建一个嵌套单元。

或者当我们想要嵌套的密集数据时，也可以创建一个嵌套单元。

> 这个嵌套单元其实是大小为d的一个特殊类型的隐藏单元；此嵌套层可与任何其它特征和隐藏层组合。和任何DNN中一样，最终层将是要进行优化的损失函数。

**案例1**

假设我们正在执行协同过滤，目标是根据其他用户的兴趣，预测某位用户的兴趣。

我们可以将这个问题作为监督学习问题进行建模，具体做法是随机选择用户看过的一小部分影片作为正类标签，然后再优化Softmax损失。

根据协同过滤数据学习影片嵌套的DNN架构示例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 29][]

**案例2**

如果想在DNN中针对房地产广告词，创建嵌套层来预测房价，则可以将训练数据中的已知房屋价用作标签来优化来L2损失。

在学习d维嵌套时，每一项都会映射到d为空间中的一个点，这样相似项就会在该空间内彼此邻近。

嵌套层权重的几何视图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 30][]

上图说明了在嵌套层中学到的权重与几何视图之间的关系；输入节点与d维嵌套层中的节点之间的边的权重，对应于d维坐标轴中每一维的坐标值。

比如，d = 3，把每一项，映射到3位空间汇总的一个点，比如是（0.9,0.2,0.4）。

参考：[https://developers.google.cn/machine-learning/crash-course/embeddings/obtaining-embeddings][https_developers.google.cn_machine-learning_crash-course_embeddings_obtaining-embeddings]

加油加油~

本文供大家学习参考，欢迎交流~

如有错误，欢迎指出，谢谢。

[https_guo-pu.blog.csdn.net_article_details_117442581]: https://guo-pu.blog.csdn.net/article/details/117442581
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70]: /images/20221005/1473adbdcfc148ef9529af4331c3d4c3.png
[L_2]: https://latex.codecogs.com/gif.latex?L_%7B2%7D
[MSE _ _frac_1_n_sum_x_y_epsilon D_y - prediction_x_2]: https://latex.codecogs.com/gif.latex?MSE%20%3D%20%5Cfrac%7B1%7D%7Bn%7D%5Csum_%7B%28x%2Cy%29%5Cepsilon%20D%29%7D%5E%7B%7D%28y%20-%20prediction%28x%29%29%5E%7B2%7D
[https_developers.google.cn_machine-learning_crash-course_descending-into-ml_training-and-loss]: https://developers.google.cn/machine-learning/crash-course/descending-into-ml/training-and-loss
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70]: /images/20221005/2bc3059bdcc64bdcaaf4a58eb3762f2d.png
[y]: https://latex.codecogs.com/gif.latex?y%5E%7B%27%7D
[y_ _ b _ w_1_x_1]: https://latex.codecogs.com/gif.latex?y%5E%7B%27%7D%20%3D%20b%20&plus;%20w_%7B1%7Dx_%7B1%7D
[b]: https://latex.codecogs.com/gif.latex?b
[w_1]: https://latex.codecogs.com/gif.latex?w_%7B1%7D
[Link 1]: https://developers.google.cn/machine-learning/crash-course/glossary#early_stopping
[Convex Optimization]: https://web.stanford.edu/~boyd/cvxbook/bv_cvxbook.pdf
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 1]: /images/20221005/3050d6bbf2294e22bae1d5cbaea9dbbd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 2]: /images/20221005/365fe5f57f5b4137a0e5faffcd029d5d.png
[f_x_y_ _ e_2y_ sin_x]: https://latex.codecogs.com/gif.latex?f%28x%2Cy%29%20%3D%20e%5E%7B2y%7D%20sin%28x%29
[f]: https://latex.codecogs.com/gif.latex?f
[x]: https://latex.codecogs.com/gif.latex?x
[frac_partial f_partial x]: https://latex.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D
[f_x]: https://latex.codecogs.com/gif.latex?f%28x%29
[y 1]: https://latex.codecogs.com/gif.latex?y
[f_x_ _ e_2_ sin_x]: https://latex.codecogs.com/gif.latex?f%28x%29%20%3D%20e%5E%7B2%7D%20sin%28x%29
[e_2_ cos_x]: https://latex.codecogs.com/gif.latex?e%5E%7B2%7D%20cos%28x%29
[frac_partial f_partial x_x_y_ _ e_2y_cos_x]: https://latex.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%28x%2Cy%29%20%3D%20e%5E%7B2y%7Dcos%28x%29
[frac_partial f_partial x_x_y_ _ 2e_2y_sin_x]: https://latex.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%28x%2Cy%29%20%3D%202e%5E%7B2y%7Dsin%28x%29
[frac_partial f_partial x_0_1_ _ e_2_ _approx 7.4]: https://latex.codecogs.com/gif.latex?%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%280%2C1%29%20%3D%20e%5E%7B2%7D%20%5Capprox%207.4
[2021060117424859.png]: /images/20221005/9a939b72318a49d191ae2e46faae092d.png
[f_x_y]: https://latex.codecogs.com/gif.latex?f%28x%2Cy%29
[20210601175032544.png]: /images/20221005/e129d546653147968a2e8b632a16553a.png
[z _ f_x_y]: https://latex.codecogs.com/gif.latex?z%20%3D%20f%28x%2Cy%29
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 3]: /images/20221005/41595f67a1f9462a95d4b3c4ff380bc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 4]: /images/20221005/93038522f7524512be45b683522da65f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 5]: /images/20221005/70337d5b11744412979cb885e78986df.png
[https_developers.google.cn_machine-learning_crash-course_reducing-loss_an-iterative-approach]: https://developers.google.cn/machine-learning/crash-course/reducing-loss/an-iterative-approach
[https_developers.google.cn_machine-learning_crash-course_reducing-loss_gradient-descent]: https://developers.google.cn/machine-learning/crash-course/reducing-loss/gradient-descent
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 6]: /images/20221005/767ae266ca4a46e6b009d8619aef3b70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 7]: /images/20221005/4711a3a8b91e4a8ba5aec730fa690e2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_1_color_FFFFFF_t_70 8]: /images/20221005/3ade29762afb49bea2c4833dd00100ef.png
[frac_1_f_x_n]: https://latex.codecogs.com/gif.latex?%5Cfrac%7B1%7D%7Bf%28x%29%5E%7Bn%7D%7D
[https_en.wikipedia.org_wiki_Hessian_matrix]: https://en.wikipedia.org/wiki/Hessian_matrix
[https_developers.google.cn_machine-learning_crash-course_reducing-loss_learning-rate]: https://developers.google.cn/machine-learning/crash-course/reducing-loss/learning-rate
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 1]: /images/20221005/1404e0f45f2a41809563812aa0e2d237.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 2]: /images/20221005/71d60fd8dca74d41b5f1057cb147006f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 3]: /images/20221005/a70a877e7efb41d29c56023db1947fa8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 4]: /images/20221005/67585dd86c0d46a7a2f451bd60092034.png
[https_developers.google.cn_machine-learning_crash-course_generalization_peril-of-overfitting]: https://developers.google.cn/machine-learning/crash-course/generalization/peril-of-overfitting
[2021060215130618.png]: /images/20221005/385d2cc083824a408371dc2549ebaa04.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 5]: /images/20221005/c1091e4b085c465ab1314965a5b06672.png
[20210602175008400.png]: /images/20221005/00b6672f867f46d89ecc83b2cffabc06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 6]: /images/20221005/d3dfbd51437547bfbe5df9e34b40a540.png
[https_developers.google.cn_machine-learning_crash-course_training-and-test-sets_splitting-data]: https://developers.google.cn/machine-learning/crash-course/training-and-test-sets/splitting-data
[https_developers.google.cn_machine-learning_crash-course_validation_another-partition]: https://developers.google.cn/machine-learning/crash-course/validation/another-partition
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 7]: /images/20221005/d1a2485315ec46538869696194afc557.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 8]: /images/20221005/856ecdd5487b4b7fae79c3f3f15155b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 9]: /images/20221005/159939b7f1984b3da31152649141b293.png
[https_developers.google.cn_machine-learning_crash-course_representation_feature-engineering]: https://developers.google.cn/machine-learning/crash-course/representation/feature-engineering
[https_developers.google.cn_machine-learning_crash-course_representation_qualities-of-good-features]: https://developers.google.cn/machine-learning/crash-course/representation/qualities-of-good-features
[minimize_Loss_Data_Model]: https://latex.codecogs.com/gif.latex?minimize%28Loss%28Data%7CModel%29%29
[minimize_ Loss _Data _ Model_ _ complexity_Model]: https://latex.codecogs.com/gif.latex?minimize%28%20Loss%20%28Data%20%7C%20Model%29%20&plus;%20complexity%28Model%29%29
[L_2_ regularization term _ _left _ w _right _2_2_ _ w_1_2_ _w_2_2_....._w_n_2]: https://latex.codecogs.com/gif.latex?L_%7B2%7D%20regularization%20term%20%3D%20%5Cleft%20%5C%7C%20w%20%5Cright%20%5C%7C_%7B2%7D%5E%7B2%7D%20%3D%20w_%7B1%7D%5E%7B2%7D%20&plus;w_%7B2%7D%5E%7B2%7D&plus;.....&plus;w_%7Bn%7D%5E%7B2%7D
[w_1_ _ 0.2_ w_2_ _ 0.5_ w_3_ _ 5_ w_4_ _ 1_ w_5_ _ 0.25_ w_6_ _ 0.75]: https://latex.codecogs.com/gif.latex?%7Bw_%7B1%7D%20%3D%200.2%2C%20w_%7B2%7D%20%3D%200.5%2C%20w_%7B3%7D%20%3D%205%2C%20w_%7B4%7D%20%3D%201%2C%20w_%7B5%7D%20%3D%200.25%2C%20w_%7B6%7D%20%3D%200.75%7D
[w_1_2_ _ w_2_2_ _ w_3_2_ _ w_4_2_ _ w_5_2_ _w_6_2_ _ 0.2_2_ _ 0.5_2_ _ 5_2_ _ 1_2_ _0.25_2_ _0.75_2]: https://latex.codecogs.com/gif.latex?w_%7B1%7D%5E%7B2%7D%20&plus;%20w_%7B2%7D%5E%7B2%7D%20&plus;%20w_%7B3%7D%5E%7B2%7D%20&plus;%20w_%7B4%7D%5E%7B2%7D%20&plus;%20w_%7B5%7D%5E%7B2%7D%20&plus;w_%7B6%7D%5E%7B2%7D%20%3D%200.2%5E%7B2%7D%20&plus;%200.5%5E%7B2%7D%20&plus;%205%5E%7B2%7D%20&plus;%201%5E%7B2%7D%20&plus;0.25%5E%7B2%7D%20&plus;0.75%5E%7B2%7D
[0.04 _ 0.25 _ 25 _ 1 _ 0.0625 _ 0.5625 _ 26.915]: https://latex.codecogs.com/gif.latex?%3D0.04%20&plus;%200.25%20&plus;%2025%20&plus;%201%20&plus;%200.0625%20&plus;%200.5625%20%3D%2026.915
[w_3]: https://latex.codecogs.com/gif.latex?w_%7B3%7D
[minimize_Loss_Data_Model_ _ _lambda complexity_Model]: https://latex.codecogs.com/gif.latex?minimize%28Loss%28Data%7CModel%29%29%20&plus;%20%5Clambda%20complexity%28Model%29%29
[lambda]: https://latex.codecogs.com/gif.latex?%5Clambda
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 10]: /images/20221005/fe7ef95cb356423487e62fcdb073e6de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 11]: /images/20221005/51f921952e844f43aee1689737823969.png
[https_developers.google.cn_machine-learning_crash-course_regularization-for-simplicity_l2-regularization]: https://developers.google.cn/machine-learning/crash-course/regularization-for-simplicity/l2-regularization
[https_developers.google.cn_machine-learning_crash-course_regularization-for-simplicity_lambda]: https://developers.google.cn/machine-learning/crash-course/regularization-for-simplicity/lambda
[p_bark _ night]: https://latex.codecogs.com/gif.latex?p%28bark%20%7C%20night%29
[started _ p _bark _ night_ _ nights]: https://latex.codecogs.com/gif.latex?started%20%3D%20p%20%28bark%20%7C%20night%29%20*%20nights
[y _ _frac_1_1_e_-z]: https://latex.codecogs.com/gif.latex?y%20%3D%20%5Cfrac%7B1%7D%7B1&plus;e%5E%7B-z%7D%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 12]: /images/20221005/0cda58fb89de4d3eba51dc6fd7e3244b.png
[y_frac_1_1_e_-_z]: https://latex.codecogs.com/gif.latex?y%5E%7B%27%7D%3D%5Cfrac%7B1%7D%7B1&plus;e%5E%7B-%28z%29%7D%7D
[b_w_1_x_1 _ w_2_x_2 _ _......_ w_N_x_N]: https://latex.codecogs.com/gif.latex?b&plus;w_%7B1%7Dx_%7B1%20%7D&plus;%20w_%7B2%7Dx_%7B2%20%7D%20&plus;......&plus;%20w_%7BN%7Dx_%7BN%20%7D
[z _ log_frac_y_1-y]: https://latex.codecogs.com/gif.latex?z%20%3D%20log%28%5Cfrac%7By%7D%7B1-y%7D%29
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 13]: /images/20221005/da76fa2298544fd2aeb1b6ca0a024235.png
[b _ w_1_x_1_ _ w_2_x_2_ _ w_3_x_3]: https://latex.codecogs.com/gif.latex?b%20&plus;%20w_%7B1%7Dx_%7B1%7D%20&plus;%20w_%7B2%7Dx_%7B2%7D%20&plus;%20w_%7B3%7Dx_%7B3%7D
[y_frac_1_1_e_-_1_0.731]: https://latex.codecogs.com/gif.latex?y%5E%7B%27%7D%3D%5Cfrac%7B1%7D%7B1&plus;e%5E%7B-%281%29%7D%7D%3D0.731
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 14]: /images/20221005/bd79dea7dc39404190ce51165c069292.png
[LohLoss _sum_x_y_epsilon D_ - ylog_y_ - _1-y_log_1-y]: https://latex.codecogs.com/gif.latex?LohLoss%20%3D%5Csum_%7B%28x%2Cy%29%5Cepsilon%20D%7D%5E%7B%7D%20-%20ylog%28y%5E%7B%27%7D%29%20-%20%281-y%29log%281-y%5E%7B%27%7D%29
[x_y_epsilon D]: https://latex.codecogs.com/gif.latex?%28x%2Cy%29%5Cepsilon%20D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 15]: /images/20221005/b32a7a3d570344d1a81cfbb3b3f08681.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 16]: /images/20221005/bb32c002f986494cbb4c8627bb5d8b12.png
[y _ mx _ b]: https://latex.codecogs.com/gif.latex?y%20%3D%20mx%20&plus;%20b
[y_ _ b _ w_1_ x_1]: https://latex.codecogs.com/gif.latex?y%5E%7B%27%7D%20%3D%20b%20&plus;%20w_%7B1%7D%20x_%7B1%7D
[w_0]: https://latex.codecogs.com/gif.latex?w_%7B0%7D
[w1]: https://latex.codecogs.com/gif.latex?w1
[x_1]: https://latex.codecogs.com/gif.latex?x_%7B1%7D
[y_ _ b _ w_1_x_1_ _ w_2_x_2_ _ w_3_x_3]: https://latex.codecogs.com/gif.latex?y%5E%7B%27%7D%20%3D%20b%20&plus;%20w_%7B1%7Dx_%7B1%7D%20&plus;%20w_%7B2%7Dx_%7B2%7D%20&plus;%20w_%7B3%7Dx_%7B3%7D
[https_developers.google.cn_machine-learning_crash-course_descending-into-ml_linear-regression]: https://developers.google.cn/machine-learning/crash-course/descending-into-ml/linear-regression
[y_ _ b _ w_1_ x_1_ _w_2_ x_2_ _.......w_n_ x_n]: https://latex.codecogs.com/gif.latex?y%5E%7B%27%7D%20%3D%20b%20&plus;%20w_%7B1%7D%20x_%7B1%7D%20&plus;w_%7B2%7D%20x_%7B2%7D%20&plus;.......w_%7Bn%7D%20x_%7Bn%7D
[Link 2]: https://en.wikipedia.org/wiki/Statistical_inference
[https_developers.google.cn_machine-learning_crash-course_logistic-regression_calculating-a-probability]: https://developers.google.cn/machine-learning/crash-course/logistic-regression/calculating-a-probability
[https_developers.google.cn_machine-learning_crash-course_logistic-regression_model-training]: https://developers.google.cn/machine-learning/crash-course/logistic-regression/model-training
[L_1]: https://latex.codecogs.com/gif.latex?L_%7B1%7D
[left _ w _right]: https://latex.codecogs.com/gif.latex?%5Cleft%20%7C%20w%20%5Cright%20%7C
[w_2]: https://latex.codecogs.com/gif.latex?w%5E%7B2%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 17]: /images/20221005/707e4f6d3c6d4dbf81b0d8cb77be7580.png
[https_developers.google.cn_machine-learning_crash-course_regularization-for-sparsity_l1-regularization]: https://developers.google.cn/machine-learning/crash-course/regularization-for-sparsity/l1-regularization
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 18]: /images/20221005/4f0e8e788eff4378840c5f0b355098a6.png
[b _w_1_x_1_ _ w_2_x_2]: https://latex.codecogs.com/gif.latex?b%20&plus;w_%7B1%7Dx_%7B1%7D%20&plus;%20w_%7B2%7Dx_%7B2%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 19]: /images/20221005/d4759bfe6a4d43ec8e8f8d11039e8945.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 20]: /images/20221005/e2ca8fbeb047461d8fd056c521b50016.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 21]: /images/20221005/376f36a623dc4244b8f1f6c32fdb8710.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 22]: /images/20221005/73f8347af62d44c083521e8c2c561672.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 23]: /images/20221005/07c63594ec354bc483f0ef7930d63f65.png
[F_x_frac_1_1_e_-x]: https://latex.codecogs.com/gif.latex?F%28x%29%3D%5Cfrac%7B1%7D%7B1&plus;e%5E%7B-x%7D%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 24]: /images/20221005/24893d3ef94044408fa1ea258aca6f90.png
[F_x_max_0_x]: https://latex.codecogs.com/gif.latex?F%28x%29%3Dmax%280%2Cx%29
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 25]: /images/20221005/9c09c5b775c84795bee4b6d26cf79ee7.png
[sigma]: https://latex.codecogs.com/gif.latex?%5Csigma
[sigma _w_cdot x_b]: https://latex.codecogs.com/gif.latex?%5Csigma%20%28w%5Ccdot%20x&plus;b%29
[https_developers.google.cn_machine-learning_crash-course_introduction-to-neural-networks_anatomy]: https://developers.google.cn/machine-learning/crash-course/introduction-to-neural-networks/anatomy
[20210610110815389.png]: /images/20221005/382f3cd456e349bf91351bb30e253bee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 26]: /images/20221005/99f6ea3b6f1540cb9211dedc05111c2d.png
[https_developers.google.cn_machine-learning_crash-course_embeddings_motivation-from-collaborative-filtering]: https://developers.google.cn/machine-learning/crash-course/embeddings/motivation-from-collaborative-filtering
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 27]: /images/20221005/b77f5c63148e4f538869b2f49b8630fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 28]: /images/20221005/202eed88cad84a0597d9e299660faa4f.png
[https_developers.google.cn_machine-learning_crash-course_embeddings_translating-to-a-lower-dimensional-space]: https://developers.google.cn/machine-learning/crash-course/embeddings/translating-to-a-lower-dimensional-space
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 29]: /images/20221005/66bc667d116c429c85fd732036edf64a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMjA0NDY0_size_16_color_FFFFFF_t_70 30]: /images/20221005/8b8d5e5566094111a96fba24ddef9024.png
[https_developers.google.cn_machine-learning_crash-course_embeddings_obtaining-embeddings]: https://developers.google.cn/machine-learning/crash-course/embeddings/obtaining-embeddings