2020-08-15 19:24:44

docs/tf-1x-dl-cookbook/06.md

@@ -61,9 +61,9 @@ Examples of gradient
 
 An example of gradient clipping
 
-解决梯度消失的问题需要一种更复杂的内存模型，该模型可以选择性地忘记先前的状态，只记住真正重要的状态。 考虑下图，输入以 *[0,1]* 中的 *p* 的概率写入存储器 *M* 中，并乘以加权输入。
+解决梯度消失的问题需要一种更复杂的内存模型，该模型可以选择性地忘记先前的状态，只记住真正重要的状态。 考虑下图，输入以`[0,1]`中的概率`p`写入存储器`M`中，并乘以加权输入。
 
-以类似的方式，以 *[0,1]* 中的 *p* 的概率读取输出，将其乘以加权输出。 还有一种可能性用来决定要记住或忘记的事情：
+以类似的方式，以`[0,1]`中的概率`p`读取输出，将其乘以加权输出。 还有一种可能性用来决定要记住或忘记的事情：
 
 ![](img/7b32ca16-e98a-4ab0-b732-215739cc11fc.png)
 
@@ -77,15 +77,17 @@ LSTM 网络可以控制何时让输入进入神经元，何时记住在上一个
 
 An example of an LSTM cell
 
-首先，我们需要一个逻辑函数σ（请参见第 2 章，“回归”）来计算介于 0 和 1 之间的值，并控制哪些信息流过 LSTM *门[* 。 请记住，逻辑函数是可微的，因此允许反向传播。 然后，我们需要一个运算符⊗，它采用两个相同维的矩阵并生成另一个矩阵，其中每个元素 *ij* 是原始两个矩阵的元素 *ij* 的乘积。 同样，我们需要一个运算符⊕，它采用两个相同维度的矩阵并生成另一个矩阵，其中每个元素 *ij* 是原始两个矩阵的元素 *ij* 之和。 使用这些基本块，我们考虑时间 i 处的输入 X <sub>i</sub> ，并将其与上一步中的输出 Y <sub>i-1</sub> 并置。
+首先，我们需要一个逻辑函数σ（请参见第 2 章，“回归”）来计算介于 0 和 1 之间的值，并控制哪些信息流过 *LSTM 门*。 请记住，逻辑函数是可微的，因此允许反向传播。 然后，我们需要一个运算符`⊗`，它采用两个相同维的矩阵并生成另一个矩阵，其中每个元素`ij`是原始两个矩阵的元素`ij`的乘积。 同样，我们需要一个运算符`⊕`，它采用两个相同维度的矩阵并生成另一个矩阵，其中每个元素`ij`是原始两个矩阵的元素`ij`之和。 使用这些基本块，我们考虑时间`i`处的输入`X[i]`，并将其与上一步中的输出`Y[i-1]`并置。
 
-方程 *f <sub>t</sub> =σ（W <sub>f</sub> 。[y <sub>i-1</sub> ，x <sub>t</sub> ] + b [HTG9 f* 实现了控制激活门 log 的逻辑回归，并用于确定应从*先前*候选值 C <sub>i-1</sub> 获取多少信息。 传递给下一个候选值 C <sub>i</sub> （此处 *W <sub>f</sub>* 和 *b <sub>f</sub>* 矩阵和用于 logistic 回归的偏差。）如果 logistic 输出为 1，则表示*不要忘记*先前的单元格状态 C <sub>i-1；</sub> 如果输出 0， 这将意味着*忘记*先前的单元状态 C <sub>i-1</sub> 。（0,1）中的任何数字都将表示要传递的信息量。
+方程`f[t] = σ(W[f] · [y[i-1], x[t]] + b[f])`实现了控制激活门`⊗`的逻辑回归，并用于确定应从*先前*候选值`C[i-1]`获取多少信息。 传递给下一个候选值`C[i]`（此处`W[f]`和`b[f]`矩阵和用于 logistic 回归的偏差）。如果 logistic 输出为 1，则表示*不要忘记*先前的单元格状态`C[i-1]`；如果输出 0， 这将意味着*忘记*先前的单元状态`C[i-1]`。`(0, 1)`中的任何数字都将表示要传递的信息量。
 
-然后我们有两个方程： *s <sub>i</sub> =σ（W <sub>s</sub> [Y <sub>i-1</sub> ，x <sub>i</sub> ] + b <sub>s</sub>* ），用于通过 control 控制多少信息*Ĉ <sub>i</sub> = tanh（W <sub>C</sub> 。[Y <sub>应该将*当前*单元产生的 i-1</sub> ，x <sub>i</sub> + b <sub>*c*</sub>* 根据上图中表示的方案，通过运算符来获得下一个候选值 C <sub>i</sub> 。
+然后我们有两个方程：`s[i] = σ(W[s] · [Y[i-1], x[i]] + b[s])`，用于通过`⊗`控制由当前单元产生的多少信息（`Ĉ[i] = tanh(W [C] · [Y[i-1]， X[i] + b[c])`）应该通过`⊕`运算符添加到下一个候选值`C[i]`中，根据上图中表示的方案。
 
-为了实现与运算符⊕和 discussed 讨论的内容，我们需要另一个方程，其中实际的和+和乘法*发生： *C <sub>i</sub> = f <sub>t</sub> * C <sub>i-1</sub> + s <sub>i</sub> *Ĉ <sub>i</sub>*
+为了实现与运算符`⊕`和`⊗`所讨论的内容，我们需要另一个方程，其中进行实际的加法`+`和乘法`*`：`C[i] = f[t] * C[i-1] + s[i] * Ĉ[i]`
 
-最后，我们需要确定当前单元格的哪一部分应发送到 *Y <sub>i</sub>* 输出。 这很简单：我们再进行一次逻辑回归方程，然后通过⊗运算来控制应使用哪一部分候选值输出。 在这里，有一点值得关注，使用 *tanh* 函数将输出压缩为[-1，1]。 最新的步骤由以下公式描述：![](img/3ee358ac-f71a-4d03-b74c-c170783a49fd.png)
+最后，我们需要确定当前单元格的哪一部分应发送到`Y[i]`输出。 这很简单：我们再进行一次逻辑回归方程，然后通过`⊗`运算来控制应使用哪一部分候选值输出。 在这里，有一点值得关注，使用 *tanh* 函数将输出压缩为`[-1, 1]`。 最新的步骤由以下公式描述：
+
+![](img/3ee358ac-f71a-4d03-b74c-c170783a49fd.png)
 
 现在，我了解到这看起来像很多数学运算，但有两个好消息。 首先，如果您了解我们想要实现的目标，那么数学部分并不是那么困难。 其次，您可以将 LSTM 单元用作标准 RNN 单元的黑盒替代，并立即获得解决梯度消失问题的好处。 因此，您实际上不需要了解所有数学知识。 您只需从库中获取 TensorFlow LSTM 实现并使用它即可。
 
@@ -107,11 +109,11 @@ Examples of Standard LSTM, PeepHole LSTM, and GRU
 
 An example of RNN sequences as seen in http://karpathy.github.io/2015/05/21/rnn-effectiveness/
 
-机器翻译是输入和输出中不同步序列的一个示例：网络将输入文本作为序列读取，在读取全文之后，*会输出目标语言。*
+机器翻译是输入和输出中不同步序列的一个示例：网络将输入文本作为序列读取，在读取全文之后，*会输出目标语言*。
 
 视频分类是输入和输出中同步序列的示例：视频输入是帧序列，并且对于每个帧，输出中都提供了分类标签。
 
-如果您想了解有关 RNN 有趣应用的更多信息，则必须阅读 Andrej Karpathy [发布的博客](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)。 他训练了网络，以莎士比亚的风格撰写论文（用 Karpathy 的话说：*几乎不能从实际的莎士比亚*中识别出这些样本），撰写有关虚构主题的现实 Wikipedia 文章，撰写关于愚蠢和不现实问题的现实定理证明（ 用 Karpathy 的话：*更多的幻觉代数几何*），并写出现实的 Linux 代码片段（用 Karpathy 的话：t *，他首先建模逐个字符地列举 GNU 许可证，其中包括一些示例，然后生成 一些宏，然后深入研究代码*）。
+如果您想了解有关 RNN 有趣应用的更多信息，则必须阅读 Andrej Karpathy [发布的博客](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)。 他训练了网络，以莎士比亚的风格撰写论文（用 Karpathy 的话说：*几乎*不能从实际的莎士比亚中识别出这些样本），撰写有关虚构主题的现实 Wikipedia 文章，撰写关于愚蠢和不现实问题的现实定理证明（用 Karpathy 的话：*更多的幻觉代数几何*），并写出现实的 Linux 代码片段（用 Karpathy 的话：*他首先建模逐个字符地列举 GNU 许可证，其中包括一些示例，然后生成一些宏，然后深入研究代码*）。
 
 以下示例摘自[这个页面](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)：
 
@@ -123,7 +125,7 @@ An example of text generated with RNNs
 
 序列到序列（seq2seq）是 RNN 的一种特殊类型，已成功应用于神经机器翻译，文本摘要和语音识别中。 在本食谱中，我们将讨论如何实现神经机器翻译，其结果与 [Google 神经机器翻译系统](https://research.googleblog.com/2016/09/a-neural-network-for-machine.html)。 关键思想是输入整个文本序列，理解整个含义，然后将翻译输出为另一个序列。 读取整个序列的想法与以前的体系结构大不相同，在先前的体系结构中，将一组固定的单词从一种源语言翻译成目标语言。
 
-本节的灵感来自 [Minh-Thang Luong](https://github.com/lmthang/thesis/blob/master/thesis.pdf) 的 2016 年博士学位论文*神经机器翻译* ]）。 第一个关键概念是编码器-解码器体系结构的存在，其中编码器将源句子转换为代表含义的向量。 然后，此向量通过解码器以产生翻译。 编码器和解码器都是 RNN，它们可以捕获语言中的长期依赖关系，例如性别协议和语法结构，而无需先验地了解它们，并且不需要跨语言进行 1：1 映射。 这是一种强大的功能，可实现非常流畅的翻译：
+本节的灵感来自 [Minh-Thang Luong](https://github.com/lmthang/thesis/blob/master/thesis.pdf) 的 2016 年博士学位论文*神经机器翻译*）。 第一个关键概念是编码器-解码器体系结构的存在，其中编码器将源句子转换为代表含义的向量。 然后，此向量通过解码器以产生翻译。 编码器和解码器都是 RNN，它们可以捕获语言中的长期依赖关系，例如性别协议和语法结构，而无需先验地了解它们，并且不需要跨语言进行 1：1 映射。 这是一种强大的功能，可实现非常流畅的翻译：
 
 ![](img/7af9de06-f5cd-4edc-a793-76ad408c579b.png)
 
@@ -144,7 +146,7 @@ An example of sequence models for NMT as seen in https://github.com/lmthang/thes
 *   RNN 可以具有一个嵌入层，该层将单词映射到一个嵌入空间中，在该空间中相似的单词恰好被映射得非常近。
 *   RNNs 可以使用简单的或者复发的细胞，或 LSTM，或窥视孔 LSTM，或越冬。
 
-仍然参考博士学位论文[神经机器翻译](https://github.com/lmthang/thesis/blob/master/thesis.pdf)，我们可以使用嵌入层来映射 将输入语句放入嵌入空间。 然后，有两个 RNN *粘在一起*-源语言的编码器和目标语言的解码器。 如您所见，存在多个隐藏层，并且有两个流程：前馈垂直方向连接这些隐藏层，水平方向是将知识从上一步转移到下一层的递归部分：
+仍然参考博士学位论文[神经机器翻译](https://github.com/lmthang/thesis/blob/master/thesis.pdf)，我们可以使用嵌入层来映射 将输入语句放入嵌入空间。 然后，有两个 RNN *粘在一起*——源语言的编码器和目标语言的解码器。 如您所见，存在多个隐藏层，并且有两个流程：前馈垂直方向连接这些隐藏层，水平方向是将知识从上一步转移到下一层的递归部分：
 
 ![](img/45216119-cbfa-47f0-9080-b6256eefb995.png)
 
@@ -295,7 +297,7 @@ An example of BLEU metric in Tensorboard
 
 # 神经机器翻译-推理 seq2seq RNN
 
-在此配方中，我们使用先前配方的结果将源语言转换为目标语言。 这个想法非常简单：给源语句提供两个组合的 RNN（编码器+解码器）作为输入。 句子一结束，解码器将发出 logit 值，我们*贪婪地*发出与最大值关联的单词。 例如，从解码器发出单词 *moi* 作为第一个令牌，因为该单词具有最大 logit 值。 之后，会发出单词 *suis* ，依此类推：
+在此配方中，我们使用先前配方的结果将源语言转换为目标语言。 这个想法非常简单：给源语句提供两个组合的 RNN（编码器+解码器）作为输入。 句子一结束，解码器将产生对率值，我们*贪婪地*产生与最大值关联的单词。 例如，从解码器产生单词`moi`作为第一个令牌，因为该单词具有最大对率值。 之后，会产生单词`suis`，依此类推：
 
 ![](img/7c5d2780-428a-40ef-9016-4487daf95aa4.jpg)
 
@@ -303,9 +305,9 @@ An example of sequence models for NMT with probabilities as seen in https://gith
 
 使用解码器的输出有多种策略：
 
-*   **贪婪**：发出与最大 logit 对应的字
-*   **采样**：通过对 logits 发出的 logit 进行采样来发出单词
-*   **波束搜索**：一个以上的预测，因此创建了可能的扩展树
+*   **贪婪**：产生与最大对率对应的字
+*   **采样**：通过对对率产生的对率进行采样来产生单词
+*   **集束搜索**：一个以上的预测，因此创建了可能的扩展树
 
 # 怎么做...
 
@@ -341,14 +343,14 @@ python -m nmt.nmt \
 
 # 这个怎么运作...
 
-将两个 RNN *打包在一起*，以形成编码器-解码器 RNN 网络。 解码器发出 logit，然后将其贪婪地转换为目标语言的单词。 例如，此处显示了从越南语到英语的自动翻译：
+将两个 RNN *打包在一起*，以形成编码器-解码器 RNN 网络。 解码器产生 logit，然后将其贪婪地转换为目标语言的单词。 例如，此处显示了从越南语到英语的自动翻译：
 
 *   **用英语输入的句子**：小时候，我认为朝鲜是世界上最好的国家，我经常唱歌&。 我们没有什么可嫉妒的。
 *   **翻译成英语的输出句子**：当我非常好时，我将去了解最重要的事情，而我不确定该说些什么。
 
 # 您只需要关注-seq2seq RNN 的另一个示例
 
-在本食谱中，我们介绍了**注意**方法，这是神经网络翻译的最新解决方案。 Dzmitry Bahdanau，Kyunghyun Cho 和 Yoshua Bengio（ICLR，2015，https：// arxiv。 org / abs / 1409.0473），它包括在编码器和解码器 RNN 之间添加其他连接。 实际上，仅将解码器与编码器的最新层连接会带来信息瓶颈，并且不一定允许通过先前的编码器层获取的信息通过。 下图说明了采用的解决方案：
+在本食谱中，我们介绍了[**注意**方法](https://arxiv.org/abs/1409.0473)（Dzmitry Bahdanau，Kyunghyun Cho 和 Yoshua Bengio，ICLR 2015），这是神经网络翻译的最新解决方案。 ，它包括在编码器和解码器 RNN 之间添加其他连接。 实际上，仅将解码器与编码器的最新层连接会带来信息瓶颈，并且不一定允许通过先前的编码器层获取的信息通过。 下图说明了采用的解决方案：
 
 ![](img/536457c9-7581-40ca-b61c-f38683038302.jpg)
 
@@ -364,7 +366,7 @@ An example of attention model for NMT as seen in https://github.com/lmthang/thes
 
 我们按以下步骤进行：
 
-1.  使用库`tf.contrib.seq2seq.LuongAttention`定义注意力机制，该库实现了 Minh-Thang Luong，Hieu Pham 和 Christopher D. Manning（2015 年）在*基于注意力的神经机器翻译有效方法*中定义的注意力模型。 ）：
+1.  使用库`tf.contrib.seq2seq.LuongAttention`定义注意力机制，该库实现了 Minh-Thang Luong，Hieu Pham 和 Christopher D. Manning（2015 年）在*基于注意力的神经机器翻译有效方法*中定义的注意力模型：
 
 ```py
 # attention_states: [batch_size, max_time, num_units]

docs/tf-1x-dl-cookbook/07.md

@@ -21,17 +21,17 @@
 
 # 主成分分析
 
-**主成分分析**（**PCA**）是用于降维的最流行的多元统计技术。 它分析了由几个因变量组成的训练数据，这些因变量通常是相互关联的，并以一组称为**主成分**的新正交变量的形式从训练数据中提取重要信息。 我们可以使用两种方法执行 PCA-**本征分解**或**奇异值分解**（**SVD**）。
+**主成分分析**（**PCA**）是用于降维的最流行的多元统计技术。 它分析了由几个因变量组成的训练数据，这些因变量通常是相互关联的，并以一组称为**主成分**的新正交变量的形式从训练数据中提取重要信息。 我们可以使用两种方法执行 PCA -- **特征值分解**或**奇异值分解**（**SVD**）。
 
 # 做好准备
 
-PCA 将 *n* 维输入数据还原为 *r* 维输入数据，其中 *r* < *n* 。 简单来说，PCA 涉及平移原点并执行轴的旋转，以使其中一个轴（主轴）与数据点的差异最小。 通过执行此变换，然后以高方差落下（删除）正交轴，可以从原始数据集中获得降维数据集。 在这里，我们采用 SVD 方法降低 PCA 尺寸。 考虑 *X* ， *n* 维数据， *p* 点 *X* <sub>*p* ， *n*</sub> 。 任何实数（ *p* × *n* ）矩阵都可以分解为：
+PCA 将`n`维输入数据还原为`r`维输入数据，其中`r < n`。 简单来说，PCA 涉及平移原点并执行轴的旋转，以使其中一个轴（主轴）与数据点的差异最小。 通过执行此变换，然后以高方差落下（删除）正交轴，可以从原始数据集中获得降维数据集。 在这里，我们采用 SVD 方法降低 PCA 尺寸。 考虑`X`，`n`维数据，具有`p`个点`X[p,n]`。 任何实数（`p × n`）矩阵都可以分解为：
 
-*X = U ∑ V <sup>T</sup>*
+`X = U ∑ V^T`
 
-在这里， *U* 和 *V* 是正交矩阵（即 *UU <sup>T</sup>* *=* *V <sup>T</sup> .V = 1* ）的大小分别为 *p* × *n* 和 *n* × *n* 。 *∑* 是大小为 *n* × *n* 的对角矩阵。 接下来，将 *∑* 矩阵切成 *r* 列，得到 *∑ <sub>r</sub>* ； 使用 *U* 和 *V* ，我们找到了降维数据点 *Y <sub>r</sub>* ：
+在这里， `U`和`V`是正交矩阵（即`U · U^T = V^T · V = E`），大小分别为`p × n`和`n × n`。 `∑`是大小为`n × n`的对角矩阵。 接下来，将`∑`矩阵切成`r`列，得到`∑[r]`； 使用`U`和`V`，我们找到了降维数据点`Y[r]`：
 
-*Y <sub>r</sub> = U∑ <sub>r</sub>*
+`Y[r] = U ∑[r]`
 
 [此处提供的代码已从以下 GitHub 链接进行改编](https://github.com/eliorc/Medium/blob/master/PCA-tSNE-AE.ipynb)
 
@@ -85,7 +85,7 @@ def fit(self):
             self._u, self._singular_values, self._sigma = session.run([u, singular_values, sigma], feed_dict={self._X: self._data})
 ```
 
-5.  现在我们有了 sigma 矩阵，正交 U 矩阵和奇异值，我们通过定义`reduce`方法来计算降维数据。 该方法需要两个输入参数之一`n_dimensions`或`keep_info`。 `n_dimensions`参数表示我们要保留在降维数据集中的维数。 另一方面，`keep_info`参数确定我们要保留的信息的百分比（值为 0.8 表示我们要保留 80％的原始数据）。 该方法创建一个切片 Sigma 矩阵的图，并计算降维数据集 *Y <sub>r</sub>* ：
+5.  现在我们有了 sigma 矩阵，正交 U 矩阵和奇异值，我们通过定义`reduce`方法来计算降维数据。 该方法需要两个输入参数之一`n_dimensions`或`keep_info`。 `n_dimensions`参数表示我们要保留在降维数据集中的维数。 另一方面，`keep_info`参数确定我们要保留的信息的百分比（值为 0.8 表示我们要保留 80％的原始数据）。 该方法创建一个切片 Sigma 矩阵的图，并计算降维数据集`Y[r]`：
 
 ```py
 def reduce(self, n_dimensions=None, keep_info=None):
@@ -189,13 +189,13 @@ with tf.Session() as sess:
 
 顾名思义，k 均值聚类是一种对数据进行聚类的技术，即将数据划分为指定数量的数据点。 这是一种无监督的学习技术。 它通过识别给定数据中的模式来工作。 还记得哈利波特成名的分拣帽子吗？ 书中的工作是聚类-将新生（未标记）的学生分成四个不同的类：格兰芬多，拉文克劳，赫奇帕奇和斯莱特林。
 
-人类非常擅长将对象分组在一起。 聚类算法试图为计算机提供类似的功能。 有许多可用的聚类技术，例如“层次”，“贝叶斯”或“局部”。 k 均值聚类属于部分聚类； 它将数据划分为 *k* 簇。 每个群集都有一个中心，称为**重心**。 群集数 *k* 必须由用户指定。
+人类非常擅长将对象分组在一起。 聚类算法试图为计算机提供类似的功能。 有许多可用的聚类技术，例如“层次”，“贝叶斯”或“局部”。 k 均值聚类属于部分聚类； 它将数据划分为`k`簇。 每个簇都有一个中心，称为**重心**。 簇数`k`必须由用户指定。
 
 k 均值算法以以下方式工作：
 
-1.  随机选择 *k* 个数据点作为初始质心（集群中心）
+1.  随机选择`k`个数据点作为初始质心（集群中心）
 2.  将每个数据点分配给最接近的质心； 可以找到接近度的不同方法，最常见的是欧几里得距离
-3.  使用当前群集成员资格重新计算质心，以使平方和的距离减小
+3.  使用当前簇成员资格重新计算质心，以使平方和的距离减小
 4.  重复最后两个步骤，直到达到收敛
 
 # 做好准备
@@ -293,7 +293,7 @@ def input_fn():
  return tf.constant(np.array(x), tf.float32, x.shape),None
 ```
 
-5.  现在我们使用`KmeansClustering`类； 在这里，我们已经知道类的数量为 3，因此我们将`num_clusters=3`设置为。 通常，我们不知道集群的数量。 在这种情况下，常用的方法是**肘法**：
+5.  现在我们使用`KmeansClustering`类； 在这里，我们已经知道类的数量为 3，因此我们将`num_clusters=3`设置为。 通常，我们不知道集群的数量。 在这种情况下，常用的方法是**肘部法则**：
 
 ```py
 kmeans = tf.contrib.learn.KMeansClustering(num_clusters=3, relative_tolerance=0.0001, random_seed=2) 
@@ -333,39 +333,39 @@ ScatterPlot(x[:,0], x[:,1], assignments, clusters)
 
 ![](img/51154394-5bbd-4d1d-9c74-31c9bc39a862.png)
 
-**+** 标记是三个簇的质心。
+`+`标记是三个簇的质心。
 
 # 这个怎么运作...
 
-前面的配方使用 TensorFlow 的 k 均值聚类估计器将给定数据聚类为聚类。 在这里，由于我们知道集群的数量，我们决定保留`num_clusters=3`，但是在大多数情况下，如果使用未标记的数据，则永远无法确定存在多少集群。 可以使用弯头法确定最佳簇数。 该方法基于以下原则：我们应选择能减少**平方误差和**（**SSE**）距离的簇数。 如果 *k* 是簇数，则随着 *k* 增加，SSE 减少，SSE = 0； 当 *k* 等于数据点数时，每个点都是其自己的簇。 我们想要一个 *k* 较低的值，以使 SSE 也较低。 在 TensorFlow 中，我们可以使用`KmeansClustering`类中定义的`score()`方法找到 SSE； 该方法将距离的总和返回到最近的聚类：
+前面的配方使用 TensorFlow 的 k 均值聚类估计器将给定数据聚类为聚类。 在这里，由于我们知道集群的数量，我们决定保留`num_clusters=3`，但是在大多数情况下，如果使用未标记的数据，则永远无法确定存在多少集群。 可以使用弯头法确定最佳簇数。 该方法基于以下原则：我们应选择能减少**平方误差和**（**SSE**）距离的簇数。 如果`k`是簇数，则随着`k`增加，SSE 减少，SSE = 0； 当`k`等于数据点数时，每个点都是其自己的簇。 我们想要一个`k`较低的值，以使 SSE 也较低。 在 TensorFlow 中，我们可以使用`KmeansClustering`类中定义的`score()`方法找到 SSE； 该方法将距离的总和返回到最近的聚类：
 
 ```py
 sum_distances = kmeans.score(input_fn=input_fn, steps=100)
 ```
 
-对于虹膜数据，如果我们针对不同的 *k* 值绘制 SSE，则可以看到对于 *k = 3* 而言，SSE 的方差最高； 之后，它开始减小，因此肘点为 *k = 3* ：
+对于虹膜数据，如果我们针对不同的`k`值绘制 SSE，则可以看到对于`k = 3`而言，SSE 的方差最高； 之后，它开始减小，因此肘点为`k = 3`：
 
 ![](img/fc2034f7-b673-471b-8ba0-8b1fdb58810c.png)
 
 # 还有更多...
 
-K 均值聚类非常流行，因为它快速，简单且健壮。 它还有一些缺点：最大的缺点是用户必须指定群集的数量。 其次，该算法不能保证全局最优。 第三，它对异常值非常敏感。
+K 均值聚类非常流行，因为它快速，简单且健壮。 它还有一些缺点：最大的缺点是用户必须指定簇的数量。 其次，该算法不能保证全局最优。 第三，它对异常值非常敏感。
 
 # 也可以看看
 
-*   Kanungo，Tapas 等人。 *一种有效的 k 均值聚类算法：分析和实现*。 IEEE 关于模式分析和机器智能的交易 24.7（2002）：881-892。
+*   `Kanungo, Tapas, et al. An efficient k-means clustering algorithm: Analysis and implementation. IEEE transactions on pattern analysis and machine intelligence 24.7 (2002): 881-892.`
 
-*   奥尔特加，华金·佩雷斯（JoaquínPérez）等人。 *关于 k 均值算法的研究问题：使用 matlab* 的实验性试验。 CEUR 研讨会论文集：语义网和新技术。
+*   `Ortega, Joaquín Pérez, et al. Research issues on k-means algorithm: An experimental trial using matlab. CEUR Workshop Proceedings: Semantic Web and New Technologies.`
 
 *   <http://home.deib.polimi.it/matteucc/Clustering/tutorial_html/kmeans.html>
 
-*   陈可 *关于度量和欧几里得空间中 k 均值和 k 均值聚类的核心集及其应用*。 SIAM 计算学报 39.3（2009）：923-947。
+*   `Chen, Ke. On coresets for k-median and k-means clustering in metric and euclidean spaces and their applications. SIAM Journal on Computing 39.3 (2009): 923-947.`
 
 *   <https://en.wikipedia.org/wiki/Determining_the_number_of_clusters_in_a_data_set>
 
 # 自组织图
 
-**自组织地图**（**SOM**），有时也称为 **Kohonen 网络**或**获胜者获得所有单位**（**WTU**），是一种非常特殊的神经网络，受人脑的独特特征驱动。 在我们的大脑中，不同的感觉输入以拓扑有序的方式表示。 与其他神经网络不同，神经元并非都通过权重相互连接，而是会影响彼此的学习。 SOM 的最重要方面是神经元以拓扑方式表示学习的输入。
+**自组织地图**（**SOM**），有时也称为 **Kohonen 网络**或**胜者通吃单元**（**WTU**），是一种非常特殊的神经网络，受人脑的独特特征驱动。 在我们的大脑中，不同的感觉输入以拓扑有序的方式表示。 与其他神经网络不同，神经元并非都通过权重相互连接，而是会影响彼此的学习。 SOM 的最重要方面是神经元以拓扑方式表示学习的输入。
 
 在 SOM 中，神经元通常放置在（1D 或 2D）晶格的节点上。 更大的尺寸也是可能的，但实际上很少使用。 晶格中的每个神经元都通过权重矩阵连接到所有输入单元。 在这里，您可以看到一个具有 3 x 4（12 个神经元）和七个输入的 SOM。 为了清楚起见，仅显示将所有输入连接到一个神经元的权重向量。 在这种情况下，每个神经元将具有七个元素，从而形成大小为（12 x 7）的组合权重矩阵：