2021-12-15 22:02:30

d954c5c2 · wizardforcel · eafd1a6a · d954c5c2 · d954c5c2 · d954c5c2
55 changed file
--- a/docs/dl-keras/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras.md
+++ b/docs/dl-keras/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras.md
@@ -105,7 +105,7 @@ numpy.random.seed(seed)
 (X_train, y_train), (X_test, y_test) = mnist.load_data()
 ```

-训练数据集被构造为实例，图像宽度和图像高度的三维阵列。对于多层感知器模型，我们必须将图像缩小为像素向量，在这种情况下，28×28 大小的图像将是 784 像素输入值。
+训练数据集被构造为实例，图像宽度和图像高度的三维数组。对于多层感知器模型，我们必须将图像缩小为像素向量，在这种情况下，28×28 大小的图像将是 784 像素输入值。

 我们可以使用 NumPy 数组上的 [reshape（）函数](http://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.reshape.html)轻松地进行转换，我们还可以通过强制像素值的精度为 32 位来降低我们的内存需求，这是 Keras 使用的默认精度。


--- a/docs/dl-keras/understanding-stateful-lstm-recurrent-neural-networks-python-keras.md
+++ b/docs/dl-keras/understanding-stateful-lstm-recurrent-neural-networks-python-keras.md
@@ -115,7 +115,7 @@ X -> Y
 Y -> Z
 ```

-我们需要将 NumPy 阵列重新整形为 LSTM 网络所期望的格式，即[_ 样本，时间步长，特征 _]。
+我们需要将 NumPy 数组重新整形为 LSTM 网络所期望的格式，即[_ 样本，时间步长，特征 _]。

 ```py
 # reshape X to be [samples, time steps, features]

--- a/docs/dl-nlp/develop-a-caption-generation-model-in-keras.md
+++ b/docs/dl-nlp/develop-a-caption-generation-model-in-keras.md
@@ -299,7 +299,7 @@ Keras 直接提供这种预先训练的模型。请注意，第一次使用此

 Keras 还提供了用于将加载的照片整形为模型的优选尺寸的工具（例如，3 通道 224×224 像素图像）。

-下面是一个名为`extract_features()`的函数，给定目录名称将加载每张照片，为 VGG 准备并从 VGG 模型中收集预测的特征。图像特征是具有形状（7,7,512）的三维阵列。
+下面是一个名为`extract_features()`的函数，给定目录名称将加载每张照片，为 VGG 准备并从 VGG 模型中收集预测的特征。图像特征是具有形状（7,7,512）的三维数组。

 该函数返回图像标识符的字典到图像特征。


--- a/docs/dl-nlp/prepare-photo-caption-dataset-training-deep-learning-model.md
+++ b/docs/dl-nlp/prepare-photo-caption-dataset-training-deep-learning-model.md
@@ -114,7 +114,7 @@ from keras.preprocessing.image import load_img
 image = load_img('990890291_afc72be141.jpg')
 ```

-像素数据需要转换为 NumPy 阵列以便在 Keras 中使用。
+像素数据需要转换为 NumPy 数组以便在 Keras 中使用。

 我们可以使用`img_to_array()`keras 函数来转换加载的数据。


--- a/docs/dl-ts/cnn-models-for-human-activity-recognition-time-series-classification.md
+++ b/docs/dl-ts/cnn-models-for-human-activity-recognition-time-series-classification.md
@@ -121,7 +121,7 @@ def load_file(filepath):
 	return dataframe.values
 ```

-然后，我们可以将给定组（训练或测试）的所有数据加载到单个三维 NumPy 阵列中，其中阵列的尺寸为[_ 样本，时间步长，特征 _]。
+然后，我们可以将给定组（训练或测试）的所有数据加载到单个三维 NumPy 数组中，其中数组的尺寸为[_ 样本，时间步长，特征 _]。

 为了更清楚，有 128 个时间步和 9 个特征，其中样本数是任何给定原始信号数据文件中的行数。


--- a/docs/dl-ts/deep-learning-models-for-human-activity-recognition.md
+++ b/docs/dl-ts/deep-learning-models-for-human-activity-recognition.md
@@ -109,7 +109,7 @@ x, 		y, 		z, 		activity

 如果数据以 8 Hz 记录，则意味着执行活动所用的一秒钟将有八行数据。

-我们可以选择让一个数据窗口代表一秒钟的数据;这意味着 8 Hz 传感器有 8 行数据。如果我们有 x，y 和 z 数据，那意味着我们将有 3 个变量。因此，单个数据窗口将是具有八个时间步长和三个特征的二维阵列。
+我们可以选择让一个数据窗口代表一秒钟的数据;这意味着 8 Hz 传感器有 8 行数据。如果我们有 x，y 和 z 数据，那意味着我们将有 3 个变量。因此，单个数据窗口将是具有八个时间步长和三个特征的二维数组。

 一个窗口代表一个样本。一分钟的数据代表 480 个传感器数据点，或 60 个 8 个时间步长的窗口。总共 10 分钟的数据将代表 4,800 个数据点，或 600 个数据窗口。

@@ -119,7 +119,7 @@ x, 		y, 		z, 		activity
 [samples, time steps, features]
 ```

-我们以 8 Hz 记录的 10 分钟加速度计数据的示例将被概括为具有以下尺寸的三维阵列：
+我们以 8 Hz 记录的 10 分钟加速度计数据的示例将被概括为具有以下尺寸的三维数组：

 ```py
 [600, 8, 3]

--- a/docs/dl-ts/how-to-develop-baseline-forecasts-for-multi-site-multivariate-air-pollution-time-series-forecasting.md
+++ b/docs/dl-ts/how-to-develop-baseline-forecasts-for-multi-site-multivariate-air-pollution-time-series-forecasting.md
@@ -526,7 +526,7 @@ def forecast_chunks(train_chunks, test_input):

 我们现在可以实现`forecast_variable()`的一个版本，该版本计算给定系列的平均值，并预测每个提前期的平均值。

-首先，我们必须在所有块中收集目标列中的所有观测值，然后计算观测值的平均值，同时忽略 NaN 值。`nanmean()`NumPy 函数将计算阵列的平均值并忽略`NaN`值。
+首先，我们必须在所有块中收集目标列中的所有观测值，然后计算观测值的平均值，同时忽略 NaN 值。`nanmean()`NumPy 函数将计算数组的平均值并忽略`NaN`值。

 下面的`forecast_variable()`函数实现了这种行为。


--- a/docs/dl-ts/how-to-develop-convolutional-neural-network-models-for-time-series-forecasting.md
+++ b/docs/dl-ts/how-to-develop-convolutional-neural-network-models-for-time-series-forecasting.md
@@ -622,7 +622,7 @@ model = Model(inputs=[visible1, visible2], outputs=output)

 此模型要求输入作为两个元素的列表提供，其中列表中的每个元素包含一个子模型的数据。

-为了实现这一点，我们可以将 3D 输入数据分成两个独立的输入数据阵列;这是从一个形状为[7,3,2]的数组到两个 3D 数组[7,3,1]
+为了实现这一点，我们可以将 3D 输入数据分成两个独立的输入数据数组;这是从一个形状为[7,3,2]的数组到两个 3D 数组[7,3,1]

 ```py
 # one time series per head
@@ -1011,7 +1011,7 @@ model.compile(optimizer='adam', loss='mse')

 多输出 1D CNN 用于多元时间序列预测的图

-在训练模型时，每个样本需要三个独立的输出阵列。我们可以通过将具有形状[7,3]的输出训练数据转换为具有形状[7,1]的三个阵列来实现这一点。
+在训练模型时，每个样本需要三个独立的输出数组。我们可以通过将具有形状[7,3]的输出训练数据转换为具有形状[7,1]的三个数组来实现这一点。

 ```py
 # separate output
@@ -1020,7 +1020,7 @@ y2 = y[:, 1].reshape((y.shape[0], 1))
 y3 = y[:, 2].reshape((y.shape[0], 1))
 ```

-可以在训练期间将这些阵列提供给模型。
+可以在训练期间将这些数组提供给模型。

 ```py
 # fit model

--- a/docs/dl-ts/how-to-develop-deep-learning-models-for-univariate-time-series-forecasting.md
+++ b/docs/dl-ts/how-to-develop-deep-learning-models-for-univariate-time-series-forecasting.md
@@ -578,7 +578,7 @@ yhat = model.predict(x_input, verbose=0)

 为了使预测超出已知数据的限制，这要求将最后 n 个已知观察值作为数组并用作输入。

-`predict()`函数在做出预测时需要一个或多个输入样本，因此提供单个样本需要阵列具有`[1, n_input]`形状，其中`n_input`是模型期望作为输入的时间步数。
+`predict()`函数在做出预测时需要一个或多个输入样本，因此提供单个样本需要数组具有`[1, n_input]`形状，其中`n_input`是模型期望作为输入的时间步数。

 类似地，`predict()`函数返回一个预测数组，每个样本一个作为输入提供。在一个预测的情况下，将存在具有一个值的数组。


--- a/docs/dl-ts/how-to-develop-multilayer-perceptron-models-for-time-series-forecasting.md
+++ b/docs/dl-ts/how-to-develop-multilayer-perceptron-models-for-time-series-forecasting.md
@@ -601,7 +601,7 @@ model = Model(inputs=[visible1, visible2], outputs=output)

 此模型要求输入作为两个元素的列表提供，其中列表中的每个元素包含一个子模型的数据。

-为了实现这一点，我们可以将 3D 输入数据分成两个独立的输入数据阵列：即从一个形状为[7,3,2]的阵列到两个形状为[7,3]的 2D 阵列
+为了实现这一点，我们可以将 3D 输入数据分成两个独立的输入数据数组：即从一个形状为[7,3,2]的数组到两个形状为[7,3]的 2D 数组

 ```py
 # separate input data
@@ -978,9 +978,9 @@ model.compile(optimizer='adam', loss='mse')

 多元时间序列预测的多输出 MLP 图

-在训练模型时，每个样本需要三个独立的输出阵列。
+在训练模型时，每个样本需要三个独立的输出数组。

-我们可以通过将具有形状[7,3]的输出训练数据转换为具有形状[7,1]的三个阵列来实现这一点。
+我们可以通过将具有形状[7,3]的输出训练数据转换为具有形状[7,1]的三个数组来实现这一点。

 ```py
 # separate output
@@ -989,7 +989,7 @@ y2 = y[:, 1].reshape((y.shape[0], 1))
 y3 = y[:, 2].reshape((y.shape[0], 1))
 ```

-可以在训练期间将这些阵列提供给模型。
+可以在训练期间将这些数组提供给模型。

 ```py
 # fit model

--- a/docs/dl-ts/how-to-develop-rnn-models-for-human-activity-recognition-time-series-classification.md
+++ b/docs/dl-ts/how-to-develop-rnn-models-for-human-activity-recognition-time-series-classification.md
@@ -120,7 +120,7 @@ def load_file(filepath):
 	return dataframe.values
 ```

-然后，我们可以将给定组（训练或测试）的所有数据加载到单个三维 NumPy 阵列中，其中阵列的尺寸为[_ 样本，时间步长，特征 _]。
+然后，我们可以将给定组（训练或测试）的所有数据加载到单个三维 NumPy 数组中，其中数组的尺寸为[_ 样本，时间步长，特征 _]。

 为了更清楚，有 128 个时间步和 9 个特征，其中样本数是任何给定原始信号数据文件中的行数。


--- a/docs/dl-ts/how-to-grid-search-triple-exponential-smoothing-for-time-series-forecasting-in-python.md
+++ b/docs/dl-ts/how-to-grid-search-triple-exponential-smoothing-for-time-series-forecasting-in-python.md
@@ -18,7 +18,7 @@

 让我们开始吧。

-*   **Oct8 / 2018** ：更新了 ETS 模型的拟合，以使用 NumPy 阵列修复乘法趋势/季节性问题（感谢 Amit Amola）。
+*   **Oct8 / 2018** ：更新了 ETS 模型的拟合，以使用 NumPy 数组修复乘法趋势/季节性问题（感谢 Amit Amola）。

 ![How to Grid Search Triple Exponential Smoothing for Time Series Forecasting in Python](img/ffdeee56297777b792330716ee3eddd5.jpg)


--- a/docs/dl-ts/how-to-model-human-activity-from-smartphone-data.md
+++ b/docs/dl-ts/how-to-model-human-activity-from-smartphone-data.md
@@ -494,7 +494,7 @@ def data_for_subject(X, y, sub_map, sub_id):

 数据由具有重叠的窗口组成。我们可以编写一个函数来消除这种重叠，并将窗口向下挤压给定变量，将其压缩成一个可以直接绘制为线图的长序列。

-下面的`to_series()`函数对给定变量实现此行为，例如窗户阵列。
+下面的`to_series()`函数对给定变量实现此行为，例如窗户数组。

 ```py
 # convert a series of windows to a 1D list

--- a/docs/dl-ts/how-to-use-the-timeseriesgenerator-for-time-series-forecasting-in-keras.md
+++ b/docs/dl-ts/how-to-use-the-timeseriesgenerator-for-time-series-forecasting-in-keras.md
@@ -392,7 +392,7 @@ n_input = 2
 generator = TimeseriesGenerator(dataset, dataset, length=n_input, batch_size=1)
 ```

-然后，对于 1 个样本，2 个时间步长和 2 个特征或平行序列，每个样本将是[1,2,2]的三维阵列。对于 1 个样本和 2 个特征，输出将是[1,2]的二维系列。第一个样本将是：
+然后，对于 1 个样本，2 个时间步长和 2 个特征或平行序列，每个样本将是[1,2,2]的三维数组。对于 1 个样本和 2 个特征，输出将是[1,2]的二维系列。第一个样本将是：

 ```py
 X, 							y

--- a/docs/dl-ts/multi-step-time-series-forecasting-long-short-term-memory-networks-python.md
+++ b/docs/dl-ts/multi-step-time-series-forecasting-long-short-term-memory-networks-python.md
@@ -608,7 +608,7 @@ scaler, train, test = prepare_data(series, n_test, n_lag, n_seq)

 接下来，我们需要将 LSTM 网络模型与训练数据相匹配。

-这首先要求将训练数据集从 2D 阵列[_ 样本，特征 _]转换为 3D 阵列[_ 样本，时间步长，特征 _]。我们将时间步长固定为 1，因此这种变化很简单。
+这首先要求将训练数据集从 2D 数组[_ 样本，特征 _]转换为 3D 数组[_ 样本，时间步长，特征 _]。我们将时间步长固定为 1，因此这种变化很简单。

 接下来，我们需要设计一个 LSTM 网络。我们将使用一个简单的结构，其中 1 个隐藏层具有 1 个 LSTM 单元，然后是具有线性激活和 3 个输出值的输出层。网络将使用均方误差丢失函数和有效的 ADAM 优化算法。

@@ -651,7 +651,7 @@ model = fit_lstm(train, 1, 3, 1, 1500, 1)

 下一步是使用适合的 LSTM 网络做出预测。

-通过调用 _model.predict（）_，可以使用拟合 LSTM 网络进行单个预测。同样，必须将数据格式化为具有[_ 样本，时间步长，特征 _]格式的 3D 阵列。
+通过调用 _model.predict（）_，可以使用拟合 LSTM 网络进行单个预测。同样，必须将数据格式化为具有[_ 样本，时间步长，特征 _]格式的 3D 数组。

 我们可以将它包装成一个名为`forecast_lstm()`的函数。


--- a/docs/dl-ts/multi-step-time-series-forecasting-with-machine-learning-models-for-household-electricity-consumption.md
+++ b/docs/dl-ts/multi-step-time-series-forecasting-with-machine-learning-models-for-household-electricity-consumption.md
@@ -1290,7 +1290,7 @@ sgd: [390.184] 396.7, 386.7, 337.6, 391.4, 374.0, 357.1, 473.5
 *   **调整数据准备**。在拟合每个模型之前，所有数据都被标准化并标准化;探索这些方法是否必要以及数据缩放方法的更多或不同组合是否可以带来更好的表现。
 *   **探索输入大小**。输入大小限于先前观察的七天;探索越来越少的观察日作为输入及其对模型表现的影响。
 *   **非线性算法**。探索一套非线性和集成机器学习算法，看看它们是否能提升表现，例如 SVM 和随机森林。
-*   **多变量直接模型**。开发直接模型，利用前一周的所有输入变量，而不仅仅是每日消耗的总功率。这将需要将八个变量的七天的二维阵列展平为一维向量。
+*   **多变量直接模型**。开发直接模型，利用前一周的所有输入变量，而不仅仅是每日消耗的总功率。这将需要将八个变量的七天的二维数组展平为一维向量。

 如果你探索任何这些扩展，我很想知道。


--- a/docs/dl-ts/time-series-prediction-lstm-recurrent-neural-networks-python-keras.md
+++ b/docs/dl-ts/time-series-prediction-lstm-recurrent-neural-networks-python-keras.md
@@ -201,7 +201,7 @@ trainX, trainY = create_dataset(train, look_back)
 testX, testY = create_dataset(test, look_back)
 ```

-LSTM 网络期望输入数据（X）以以下形式提供特定的阵列结构： _[样本，时间步长，特征]_ 。
+LSTM 网络期望输入数据（X）以以下形式提供特定的数组结构： _[样本，时间步长，特征]_ 。

 目前，我们的数据形式为：[_ 样本，特征 _]，我们将问题定为每个样本的一个时间步长。我们可以使用 **numpy.reshape（）**将准备好的训练和测试输入数据转换为预期结构，如下所示：


--- a/docs/linalg/SUMMARY.md
+++ b/docs/linalg/SUMMARY.md
 +   [Machine Learning Mastery 线性代数教程](README.md)
 +   [机器学习数学符号的基础知识](basics-mathematical-notation-machine-learning.md)
-+   [用 NumPy 阵列轻松介绍广播](broadcasting-with-numpy-arrays.md)
+   [用 NumPy 数组轻松介绍广播](broadcasting-with-numpy-arrays.md)
 +   [如何从 Python 中的 Scratch 计算主成分分析（PCA）](calculate-principal-component-analysis-scratch-python.md)
 +   [用于编码器审查的计算线性代数](computational-linear-algebra-coders-review.md)
 +   [10 机器学习中的线性代数示例](examples-of-linear-algebra-in-machine-learning.md)
@@ -10,7 +10,7 @@
 +   [如何在 Python 中为机器学习索引，切片和重塑 NumPy 数组](index-slice-reshape-numpy-arrays-machine-learning-python.md)
 +   [机器学习的矩阵和矩阵算法简介](introduction-matrices-machine-learning.md)
 +   [温和地介绍机器学习的特征分解，特征值和特征向量](introduction-to-eigendecomposition-eigenvalues-and-eigenvectors.md)
-+   [NumPy 对预期价值，方差和协方差的简要介绍](introduction-to-expected-value-variance-and-covariance.md)
+   [NumPy 对期望值，方差和协方差的简要介绍](introduction-to-expected-value-variance-and-covariance.md)
 +   [机器学习矩阵分解的温和介绍](introduction-to-matrix-decompositions-for-machine-learning.md)
 +   [用 NumPy 轻松介绍机器学习的张量](introduction-to-tensors-for-machine-learning.md)
 +   [用于机器学习的线性代数中的矩阵类型简介](introduction-to-types-of-matrices-in-linear-algebra.md)

--- a/docs/linalg/basics-mathematical-notation-machine-learning.md
+++ b/docs/linalg/basics-mathematical-notation-machine-learning.md
-# 机器学习数学符号的基础知识
+# 机器学习中数学符号的基础知识

 > 原文： [https://machinelearningmastery.com/basics-mathematical-notation-machine-learning/](https://machinelearningmastery.com/basics-mathematical-notation-machine-learning/)

@@ -222,7 +222,7 @@ ln(7.38905...) = 2

 机器学习符号通常描述对序列的操作。

-序列可以是数据阵列或术语列表。
+序列可以是数据数组或术语列表。

 ### 索引


--- a/docs/linalg/broadcasting-with-numpy-arrays.md
+++ b/docs/linalg/broadcasting-with-numpy-arrays.md
-# 使用 NumPy 阵列轻松介绍广播
+# NumPy 数组广播的温和介绍

 > 原文： [https://machinelearningmastery.com/broadcasting-with-numpy-arrays/](https://machinelearningmastery.com/broadcasting-with-numpy-arrays/)

 不能添加，减去或通常在算术中使用具有不同大小的数组。

-克服这个问题的一种方法是复制较小的数组，使其尺寸和大小与较大的数组相同。这称为阵列广播，在执行数组运算时可在 NumPy 中使用，这可以大大减少和简化代码。
+克服这个问题的一种方法是复制较小的数组，使其尺寸和大小与较大的数组相同。这称为数组广播，在执行数组运算时可在 NumPy 中使用，这可以大大减少和简化代码。

-在本教程中，您将发现阵列广播的概念以及如何在 NumPy 中实现它。
+在本教程中，您将发现数组广播的概念以及如何在 NumPy 中实现它。

 完成本教程后，您将了解：

 *   具有不同大小的数组的算术问题。
 *   广播的解决方案和一维和二维的常见例子。
-*   阵列广播规则和广播失败时。
+*   数组广播规则和广播失败时。

 让我们开始吧。

 ![Introduction to Broadcasting with NumPy Arrays](img/bae7772c8e64065ad2ec65a9f752813a.jpg)

-使用 NumPy 阵列进行广播的介绍
+使用 NumPy 数组进行广播的介绍
 [pbkwee](https://www.flickr.com/photos/rimuhosting/7689904958/) 的照片，保留一些权利。

 ## 教程概述
@@ -26,7 +26,7 @@
 本教程分为 4 个部分;他们是：

 1.  数组运算的局限性
-2.  阵列广播
+2.  数组广播
 3.  在 NumPy 广播
 4.  广播的局限性

@@ -45,21 +45,21 @@ c = a + b
 c = [1 + 1, 2 + 2, 3 + 3]
 ```

-严格地说，算术只能在具有相同尺寸和尺寸的相同尺寸的阵列上执行。
+严格地说，算术只能在具有相同尺寸和尺寸的相同尺寸的数组上执行。

 这意味着长度为 10 的一维数组只能与另一个长度为 10 的一维数组进行算术运算。

-对阵列算术的这种限制确实非常有限。值得庆幸的是，NumPy 提供了一个内置的解决方法，允许在具有不同大小的数组之间进行算术运算。
+对数组算术的这种限制确实非常有限。值得庆幸的是，NumPy 提供了一个内置的解决方法，允许在具有不同大小的数组之间进行算术运算。

-## 阵列广播
+## 数组广播

 广播是 NumPy 用于允许具有不同形状或大小的数组之间的数组运算的方法的名称。

 尽管该技术是针对 [NumPy](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html) 开发的，但它在其他数值计算库中也被广泛采用，例如 [Theano](http://deeplearning.net/software/theano/tutorial/broadcasting.html) ， [TensorFlow](https://www.tensorflow.org/performance/xla/broadcasting) 和 [Octave](https://www.gnu.org/software/octave/doc/v4.2.1/Broadcasting.html) 。

-广播通过实际上沿着最后的不匹配维度复制较小的阵列来解决不同形状的阵列之间的算术问题。
+广播通过实际上沿着最后的不匹配维度复制较小的数组来解决不同形状的数组之间的算术问题。

-> 术语广播描述了 numpy 如何在算术运算期间处理具有不同形状的数组。受某些约束的影响，较小的阵列在较大的阵列上“广播”，以便它们具有兼容的形状。
+> 术语广播描述了 numpy 如何在算术运算期间处理具有不同形状的数组。受某些约束的影响，较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。

 - [广播](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html)，SciPy.org

@@ -94,7 +94,7 @@ b
 b = [b1, b2, b3]
 ```

-然后可以直接添加两个一维阵列。
+然后可以直接添加两个一维数组。

 ```
 c = a + b
@@ -137,14 +137,14 @@ A = (a21, a22, a23)
 b
 ```

-标量将需要在二维阵列的每一行上进行广播，方法是将其复制 5 次。
+标量将需要在二维数组的每一行上进行广播，方法是将其复制 5 次。

 ```
     b11, b12, b13
 B = (b21, b22, b23)
 ```

-然后可以直接添加两个二维阵列。
+然后可以直接添加两个二维数组。

 ```
 C = A + B
@@ -178,9 +178,9 @@ print(C)
 [3 4 5]]
 ```

-### 一维和二维阵列
+### 一维和二维数组

-一维数组可用于具有二维阵列的算术。
+一维数组可用于具有二维数组的算术。

 例如，我们可以想象一个二维数组“A”，其中 2 行 3 列添加到具有 3 个值的一维数组“b”。

@@ -191,7 +191,7 @@ A = (a21, a22, a23)
 b = (b1, b2, b3)
 ```

-通过创建第二副本以产生新的二维阵列“B”，在二维阵列的每一行上广播一维阵列。
+通过创建第二副本以产生新的二维数组“B”，在二维数组的每一行上广播一维数组。

 ```
     b11, b12, b13
@@ -272,7 +272,7 @@ b.shape = (1 x 1)

 当比较失败时，不能执行广播，并且引发错误。

-下面的示例尝试将两元素阵列广播到 2 x 3 阵列。这种比较有效：
+下面的示例尝试将两元素数组广播到 2 x 3 数组。这种比较有效：

 ```
 A.shape = (2 x 3)
@@ -294,7 +294,7 @@ C = A + b
 print(C)
 ```

-运行该示例首先打印阵列的形状，然后在尝试广播时引发错误，正如我们预期的那样。
+运行该示例首先打印数组的形状，然后在尝试广播时引发错误，正如我们预期的那样。

 ```
 (2, 3)
@@ -306,9 +306,9 @@ ValueError: operands could not be broadcast together with shapes (2,3) (2,)

 本节列出了一些扩展您可能希望探索的教程的想法。

-*   使用 NumPy 阵列创建三个新的和不同的广播示例。
+*   使用 NumPy 数组创建三个新的和不同的广播示例。
 *   实现您自己的广播功能，以便在一维和二维情况下进行手动广播。
-*   基准 NumPy 广播和您自己的自定义广播功能，具有非常大的阵列的一维和二维情况。
+*   基准 NumPy 广播和您自己的自定义广播功能，具有非常大的数组的一维和二维情况。

 如果你探索任何这些扩展，我很想知道。

@@ -326,18 +326,18 @@ ValueError: operands could not be broadcast together with shapes (2,3) (2,)
 *   [TensorFlow](https://www.tensorflow.org/performance/xla/broadcasting) 中的广播语义
 *   [数组广播在 numpy](http://scipy.github.io/old-wiki/pages/EricsBroadcastingDoc) ，EricsBroadcastingDoc 中
 *   [广播](http://deeplearning.net/software/theano/tutorial/broadcasting.html)，Theano
-*   [Numpy](https://eli.thegreenplace.net/2015/broadcasting-arrays-in-numpy/) ，2015 年的广播阵列。
+*   [Numpy](https://eli.thegreenplace.net/2015/broadcasting-arrays-in-numpy/) ，2015 年的广播数组。
 *   [八度广播](https://www.gnu.org/software/octave/doc/v4.2.1/Broadcasting.html)

 ## 摘要

-在本教程中，您发现了阵列广播的概念以及如何在 NumPy 中实现。
+在本教程中，您发现了数组广播的概念以及如何在 NumPy 中实现。

 具体来说，你学到了：

 *   具有不同大小的数组的算术问题。
 *   广播的解决方案和一维和二维的常见例子。
-*   阵列广播规则和广播失败时。
+*   数组广播规则和广播失败时。

 你有任何问题吗？
 在下面的评论中提出您的问题，我会尽力回答。
\ No newline at end of file
--- a/docs/linalg/calculate-principal-component-analysis-scratch-python.md
+++ b/docs/linalg/calculate-principal-component-analysis-scratch-python.md
-# 如何从 Python 中的 Scratch 计算主成分分析（PCA）
+# 如何在 Python 中从零开始计算主成分分析（PCA）

 > 原文： [https://machinelearningmastery.com/calculate-principal-component-analysis-scratch-python/](https://machinelearningmastery.com/calculate-principal-component-analysis-scratch-python/)


--- a/docs/linalg/computational-linear-algebra-coders-review.md
+++ b/docs/linalg/computational-linear-algebra-coders-review.md
-# 用于编码器审查的计算线性代数
+# 面向程序员的计算线性代数回顾

 > 原文： [https://machinelearningmastery.com/computational-linear-algebra-coders-review/](https://machinelearningmastery.com/computational-linear-algebra-coders-review/)

@@ -176,11 +176,11 @@ Videos and Notebook:

 ### 第 4 部分。具有鲁棒回归的压缩感知

-这部分介绍了 NumPy 阵列（和其他地方）中使用的广播的重要概念以及在机器学习中出现很多的稀疏矩阵。
+这部分介绍了 NumPy 数组（和其他地方）中使用的广播的重要概念以及在机器学习中出现很多的稀疏矩阵。

 该部分的应用重点是使用强大的 PCA 在 CT 扫描中去除背景。

-> 术语广播描述了在算术运算期间如何处理具有不同形状的阵列。 Numpy 首先使用广播一词，但现在用于其他库，如 Tensorflow 和 Matlab;规则因库而异。
+> 术语广播描述了在算术运算期间如何处理具有不同形状的数组。 Numpy 首先使用广播一词，但现在用于其他库，如 Tensorflow 和 Matlab;规则因库而异。

 The topics covered in this lecture are:


--- a/docs/linalg/examples-of-linear-algebra-in-machine-learning.md
+++ b/docs/linalg/examples-of-linear-algebra-in-machine-learning.md
-# 10 机器学习中的线性代数示例
+# 10 个机器学习中的线性代数示例

 > 原文： [https://machinelearningmastery.com/examples-of-linear-algebra-in-machine-learning/](https://machinelearningmastery.com/examples-of-linear-algebra-in-machine-learning/)


--- a/docs/linalg/gentle-introduction-n-dimensional-arrays-python-numpy.md
+++ b/docs/linalg/gentle-introduction-n-dimensional-arrays-python-numpy.md
-# 使用 NumPy 轻松介绍 Python 中的 N 维数组
+# Python NumPy 的 N 维数组的温和介绍

 > 原文： [https://machinelearningmastery.com/gentle-introduction-n-dimensional-arrays-python-numpy/](https://machinelearningmastery.com/gentle-introduction-n-dimensional-arrays-python-numpy/)

@@ -37,7 +37,7 @@ NumPy 中的主要数据结构是 ndarray，它是 N 维数组的简写名称。

 它是内存中固定大小的数组，包含相同类型的数据，例如整数或浮点值。

-可以通过阵列上的“dtype”属性访问数组支持的数据类型。可以通过“shape”属性访问数组的维度，该属性返回描述每个维度长度的元组。还有许多其他属性。在这里了解更多：
+可以通过数组上的“dtype”属性访问数组支持的数据类型。可以通过“shape”属性访问数组的维度，该属性返回描述每个维度长度的元组。还有许多其他属性。在这里了解更多：

 *   [N 维数组](https://docs.scipy.org/doc/numpy-1.13.0/reference/arrays.ndarray.html)

@@ -65,7 +65,7 @@ float64

 ## 创建数组的函数

-有更多便利功能可用于创建您可能遇到或需要使用的固定大小的阵列。
+有更多便利功能可用于创建您可能遇到或需要使用的固定大小的数组。

 我们来看几个。您可以在此处查看完整列表：

@@ -165,7 +165,7 @@ print(a3)
 print(a3.shape)
 ```

-首先运行该示例打印两个单独定义的一维数组。阵列垂直堆叠，形成一个新的 2×3 阵列，其内容和形状被打印出来。
+首先运行该示例打印两个单独定义的一维数组。数组垂直堆叠，形成一个新的 2×3 数组，其内容和形状被打印出来。

 ```
 [1 2 3]
@@ -199,7 +199,7 @@ print(a3)
 print(a3.shape)
 ```

-首先运行该示例打印两个单独定义的一维数组。然后水平堆叠阵列，产生具有 6 个元素的新的一维阵列，其内容和形状被打印。
+首先运行该示例打印两个单独定义的一维数组。然后水平堆叠数组，产生具有 6 个元素的新的一维数组，其内容和形状被打印。

 ```
 [1 2 3]

--- a/docs/linalg/index-slice-reshape-numpy-arrays-machine-learning-python.md
+++ b/docs/linalg/index-slice-reshape-numpy-arrays-machine-learning-python.md
@@ -8,7 +8,7 @@

 如果您是 Python 的新手，您可能会对某些 [pythonic](https://stackoverflow.com/questions/25011078/what-does-pythonic-mean) 访问数据的方式感到困惑，例如负索引和数组切片。

-在本教程中，您将了解如何在 NumPy 阵列中正确操作和访问数据。
+在本教程中，您将了解如何在 NumPy 数组中正确操作和访问数据。

 完成本教程后，您将了解：

@@ -29,7 +29,7 @@

 1.  从列表到数组
 2.  数组索引
-3.  阵列切片
+3.  数组切片
 4.  数组重塑

 ## 1.从列表到数组
@@ -102,7 +102,7 @@ print(type(data))

 ## 2.数组索引

-使用 NumPy 阵列表示数据后，可以使用索引访问它。
+使用 NumPy 数组表示数据后，可以使用索引访问它。

 我们来看一些通过索引访问数据的例子。

@@ -215,7 +215,7 @@ print(data[0,])
 [11 22]
 ```

-## 3.阵列切片
+## 3.数组切片

 到现在为止还挺好;创建和索引数组看起来很熟悉。

@@ -320,7 +320,7 @@ print(X)
 print(y)
 ```

-运行该示例将打印分隔的 X 和 y 元素。注意，X 是 2D 阵列，y 是 1D 阵列。
+运行该示例将打印分隔的 X 和 y 元素。注意，X 是 2D 数组，y 是 1D 数组。

 ```
 [[11 22]
@@ -372,13 +372,13 @@ print(test)
 [[77 88 99]]
 ```

-## 4.阵列重塑
+## 4.数组重塑

 切片数据后，您可能需要重新整形。

 例如，某些库（例如 scikit-learn）可能要求将输出变量（y）的一维数组形成为具有一列的二维数组，并且每列的结果。

-一些算法，如 Keras 中的长短期记忆递归神经网络，需要将输入指定为由样本，时间步长和特征组成的三维阵列。
+一些算法，如 Keras 中的长短期记忆递归神经网络，需要将输入指定为由样本，时间步长和特征组成的三维数组。

 了解如何重塑 NumPy 数组以使您的数据满足特定 Python 库的期望非常重要。我们将看看这两个例子。

@@ -446,9 +446,9 @@ Rows: 3
 Cols: 2
 ```

-### 重塑 1D 到 2D 阵列
+### 重塑 1D 到 2D 数组

-通常需要将一维阵列重塑为具有一列和多个阵列的二维阵列。
+通常需要将一维数组重塑为具有一列和多个数组的二维数组。

 NumPy 在 NumPy 数组对象上提供 reshape（）函数，可用于重塑数据。

@@ -479,9 +479,9 @@ print(data.shape)
 (5, 1)
 ```

-### 重塑 2D 到 3D 阵列
+### 重塑 2D 到 3D 数组

-通常需要重新形成二维数据，其中每行表示序列为三维阵列，用于期望一个或多个时间步长和一个或多个特征的多个样本的算法。
+通常需要重新形成二维数据，其中每行表示序列为三维数组，用于期望一个或多个时间步长和一个或多个特征的多个样本的算法。

 一个很好的例子是 Keras 深度学习库中的 [LSTM 递归神经网络](https://keras.io/layers/recurrent/#lstm)模型。

@@ -510,7 +510,7 @@ data = data.reshape((data.shape[0], data.shape[1], 1))
 print(data.shape)
 ```

-首先运行示例打印 2D 阵列中每个维度的大小，重新整形数组，然后总结新 3D 阵列的形状。
+首先运行示例打印 2D 数组中每个维度的大小，重新整形数组，然后总结新 3D 数组的形状。

 ```
 (3, 2)

--- a/docs/linalg/introduction-matrices-machine-learning.md
+++ b/docs/linalg/introduction-matrices-machine-learning.md
@@ -34,7 +34,7 @@

 ## 什么是矩阵？

-矩阵是具有一个或多个列和一个或多个行的标量的二维阵列。
+矩阵是具有一个或多个列和一个或多个行的标量的二维数组。

 > 矩阵是数字的二维数组（表）。


--- a/docs/linalg/introduction-to-eigendecomposition-eigenvalues-and-eigenvectors.md
+++ b/docs/linalg/introduction-to-eigendecomposition-eigenvalues-and-eigenvectors.md
-# 温和地介绍机器学习的特征分解，特征值和特征向量
+# 面向机器学习的特征分解，特征值和特征向量的温和介绍

 > 原文： [https://machinelearningmastery.com/introduction-to-eigendecomposition-eigenvalues-and-eigenvectors/](https://machinelearningmastery.com/introduction-to-eigendecomposition-eigenvalues-and-eigenvectors/)


--- a/docs/linalg/introduction-to-expected-value-variance-and-covariance.md
+++ b/docs/linalg/introduction-to-expected-value-variance-and-covariance.md
-# NumPy 对预期价值，方差和协方差的简要介绍
+# NumPy 期望值，方差和协方差的简要介绍

 > 原文： [https://machinelearningmastery.com/introduction-to-expected-value-variance-and-covariance/](https://machinelearningmastery.com/introduction-to-expected-value-variance-and-covariance/)

@@ -21,7 +21,7 @@
 ![A Gentle Introduction to Expected Value, Variance, and Covariance with NumPy](img/66cef2cc9be1b9be684b0918ce2ce69f.jpg)

 NumPy
-照片由 [Robyn Jay](https://www.flickr.com/photos/learnscope/15866965009/) 对预期价值，方差和协方差的温和介绍，保留一些权利。
+照片由 [Robyn Jay](https://www.flickr.com/photos/learnscope/15866965009/) 对期望值，方差和协方差的温和介绍，保留一些权利。

 ## 教程概述

@@ -415,7 +415,7 @@ print(Sigma)

 ### 用品

-*   [维基百科的预期价值](https://en.wikipedia.org/wiki/Expected_value)
+*   [维基百科的期望值](https://en.wikipedia.org/wiki/Expected_value)
 *   维基百科上的[意思](https://en.wikipedia.org/wiki/Mean)
 *   [维基百科上的差异](https://en.wikipedia.org/wiki/Variance)
 *   [维基百科的标准偏差](https://en.wikipedia.org/wiki/Standard_deviation)

--- a/docs/linalg/introduction-to-tensors-for-machine-learning.md
+++ b/docs/linalg/introduction-to-tensors-for-machine-learning.md
-# 使用 NumPy 轻松介绍机器学习的张量
+# 面向机器学习的 NumPy 张量的温和介绍

 > 原文： [https://machinelearningmastery.com/introduction-to-tensors-for-machine-learning/](https://machinelearningmastery.com/introduction-to-tensors-for-machine-learning/)

@@ -36,7 +36,7 @@ Tensor 甚至出现在谷歌旗舰机器学习库的名称中：“TensorFlow”

 张量是向量和矩阵的推广，很容易理解为多维数组。

-> 在一般情况下，布置在具有可变轴数的规则网格上的数字阵列被称为张量。
+> 在一般情况下，布置在具有可变轴数的规则网格上的数字数组被称为张量。

 - 第 33 页，[深度学习](http://amzn.to/2B3MsuU)，2016 年。


--- a/docs/linalg/introduction-to-types-of-matrices-in-linear-algebra.md
+++ b/docs/linalg/introduction-to-types-of-matrices-in-linear-algebra.md
-# 用于机器学习的线性代数中的矩阵类型简介
+# 面向机器学习的线性代数中的矩阵类型简介

 > 原文： [https://machinelearningmastery.com/introduction-to-types-of-matrices-in-linear-algebra/](https://machinelearningmastery.com/introduction-to-types-of-matrices-in-linear-algebra/)


--- a/docs/linalg/linear-algebra-cheat-sheet-for-machine-learning.md
+++ b/docs/linalg/linear-algebra-cheat-sheet-for-machine-learning.md
-# 用于机器学习的线性代数备忘单
+# 面向机器学习的线性代数备忘单

 > 原文： [https://machinelearningmastery.com/linear-algebra-cheat-sheet-for-machine-learning/](https://machinelearningmastery.com/linear-algebra-cheat-sheet-for-machine-learning/)

@@ -30,7 +30,7 @@
 6.  矩阵分解
 7.  统计

-## 1.阵列
+## 1.数组

 有很多方法可以创建 NumPy 数组。


--- a/docs/linalg/linear-algebra-for-deep-learning.md
+++ b/docs/linalg/linear-algebra-for-deep-learning.md
-# 线性代数的深度学习
+# 面向深度学习的线性代数

 > 原文： [https://machinelearningmastery.com/linear-algebra-for-deep-learning/](https://machinelearningmastery.com/linear-algebra-for-deep-learning/)


--- a/docs/linalg/linear-algebra-machine-learning-7-day-mini-course.md
+++ b/docs/linalg/linear-algebra-machine-learning-7-day-mini-course.md
-# 用于机器学习的线性代数（7 天迷你课程）
+# 面向机器学习的线性代数（7 天迷你课程）

 > 原文： [https://machinelearningmastery.com/linear-algebra-machine-learning-7-day-mini-course/](https://machinelearningmastery.com/linear-algebra-machine-learning-7-day-mini-course/)

@@ -216,7 +216,7 @@ Post your answer in the comments below. I would love to see what you discover.

 ### 什么是矩阵？

-矩阵是具有一个或多个列和一个或多个行的标量的二维阵列。
+矩阵是具有一个或多个列和一个或多个行的标量的二维数组。

 矩阵的符号通常是大写字母，例如 A，并且条目由它们的行（i）和列（j）的二维下标引用，例如 aij。例如：


--- a/docs/linalg/linear-algebra-machine-learning.md
+++ b/docs/linalg/linear-algebra-machine-learning.md
-# 机器学习的线性代数
+# 面向机器学习的线性代数

 > 原文： [https://machinelearningmastery.com/linear-algebra-machine-learning/](https://machinelearningmastery.com/linear-algebra-machine-learning/)


--- a/docs/linalg/matrix-operations-for-machine-learning.md
+++ b/docs/linalg/matrix-operations-for-machine-learning.md
-# 机器学习矩阵运算的温和介绍
+# 面向机器学习的矩阵运算的温和介绍

 > 原文： [https://machinelearningmastery.com/matrix-operations-for-machine-learning/](https://machinelearningmastery.com/matrix-operations-for-machine-learning/)


--- a/docs/linalg/no-bullshit-guide-to-linear-algebra-review.md
+++ b/docs/linalg/no-bullshit-guide-to-linear-algebra-review.md
-# 线性代数评论没有废话指南
+# 线性代数回顾的没有废话的指南

 > 原文： [https://machinelearningmastery.com/no-bullshit-guide-to-linear-algebra-review/](https://machinelearningmastery.com/no-bullshit-guide-to-linear-algebra-review/)


--- a/docs/linalg/resources-for-linear-algebra-in-machine-learning.md
+++ b/docs/linalg/resources-for-linear-algebra-in-machine-learning.md
-# 学习机器学习线性代数的主要资源
+# 在机器学习中学习线性代数的主要资源

 > 原文： [https://machinelearningmastery.com/resources-for-linear-algebra-in-machine-learning/](https://machinelearningmastery.com/resources-for-linear-algebra-in-machine-learning/)


--- a/docs/linalg/sparse-matrices-for-machine-learning.md
+++ b/docs/linalg/sparse-matrices-for-machine-learning.md
-# 用于机器学习的稀疏矩阵的温和介绍
+# 面向机器学习的稀疏矩阵的温和介绍

 > 原文： [https://machinelearningmastery.com/sparse-matrices-for-machine-learning/](https://machinelearningmastery.com/sparse-matrices-for-machine-learning/)

@@ -156,7 +156,7 @@ Three examples include:

 SciPy 提供了使用多个数据结构创建稀疏矩阵的工具，以及将密集矩阵转换为稀疏矩阵的工具。

-在 NumPy 阵列上运行的许多线性代数 NumPy 和 SciPy 函数可以透明地在 SciPy 稀疏数组上运行。此外，使用 NumPy 数据结构的机器学习库也可以在 SciPy 稀疏数组上透明地运行，例如用于一般机器学习的 scikit-learn 和用于深度学习的 Keras。
+在 NumPy 数组上运行的许多线性代数 NumPy 和 SciPy 函数可以透明地在 SciPy 稀疏数组上运行。此外，使用 NumPy 数据结构的机器学习库也可以在 SciPy 稀疏数组上透明地运行，例如用于一般机器学习的 scikit-learn 和用于深度学习的 Keras。

 通过调用`csr_matrix()`函数，可以使用 CSR 表示将存储在 NumPy 数组中的密集矩阵转换为稀疏矩阵。

@@ -177,7 +177,7 @@ B = S.todense()
 print(B)
 ```

-运行该示例首先打印定义的密集阵列，然后是 CSR 表示，然后是重建的密集矩阵。
+运行该示例首先打印定义的密集数组，然后是 CSR 表示，然后是重建的密集矩阵。

 ```
 [[1 0 0 1 0 0]

--- a/docs/linalg/vector-norms-machine-learning.md
+++ b/docs/linalg/vector-norms-machine-learning.md
-# 机器学习中向量规范的温和介绍
+# 机器学习中向量范数的温和介绍

 > 原文： [https://machinelearningmastery.com/vector-norms-machine-learning/](https://machinelearningmastery.com/vector-norms-machine-learning/)

@@ -19,19 +19,19 @@

 ![Gentle Introduction to Vector Norms in Machine Learning](img/e4a4a58243578310240b1d079ff99795.jpg)

-机器学习中向量规范的温和介绍
+机器学习中向量范数的温和介绍
 [Cosimo](https://www.flickr.com/photos/22932473@N04/4902494396/) 的照片，保留一些权利。

 ## 教程概述

 本教程分为 4 个部分;他们是：

-1.  向量规范
-2.  向量 L1 规范
-3.  向量 L2 规范
-4.  向量最大规范
+1.  向量范数
+2.  向量 L1 范数
+3.  向量 L2 范数
+4.  向量最大范数

-## 向量规范
+## 向量范数

 通常需要直接或作为更宽向量或向量矩阵运算的一部分来计算向量的大小或长度。

@@ -47,7 +47,7 @@

 我们将看一下机器学习中使用的一些常见的向量范数计算。

-## 向量 L1 规范
+## 向量 L1 范数

 可以使用 L1 范数计算向量的长度，其中 1 是 L 的上标，例如， L ^ 1。

@@ -87,7 +87,7 @@ print(l1)

 当将机器学习算法拟合为正则化方法时，经常使用 L1 范数，例如，一种保持模型系数较小的方法，反过来，模型不那么复杂。

-## 向量 L2 规范
+## 向量 L2 范数

 可以使用 L2 范数计算向量的长度，其中 2 是 L 的上标，例如， L ^ 2。

@@ -129,9 +129,9 @@ print(l2)

 与 L1 范数一样，L2 范数经常在将机器学习算法拟合为正则化方法时使用，例如，一种保持模型系数较小的方法，反过来，模型不那么复杂。

-到目前为止，L2 规范在机器学习中比其他向量规范更常用。
+到目前为止，L2 范数在机器学习中比其他向量范数更常用。

-## 向量最大规范
+## 向量最大范数

 向量的长度可以使用最大范数来计算，也称为最大范数。


--- a/docs/linalg/why-learn-linear-algebra-for-machine-learning.md
+++ b/docs/linalg/why-learn-linear-algebra-for-machine-learning.md
-# 学习线性代数用于机器学习的 5 个理由
+# 为机器学习学习线性代数的 5 个理由

 > 原文： [https://machinelearningmastery.com/why-learn-linear-algebra-for-machine-learning/](https://machinelearningmastery.com/why-learn-linear-algebra-for-machine-learning/)


--- a/docs/lstm/encoder-decoder-attention-sequence-to-sequence-prediction-keras.md
+++ b/docs/lstm/encoder-decoder-attention-sequence-to-sequence-prediction-keras.md
@@ -232,7 +232,7 @@ print(X.shape, y.shape)
 print('X=%s, y=%s' % (one_hot_decode(X[0]), one_hot_decode(y[0])))
 ```

-运行该示例生成单个输入 - 输出对并打印两个阵列的形状。
+运行该示例生成单个输入 - 输出对并打印两个数组的形状。

 然后以解码的形式打印生成的对，其中我们可以看到序列的前两个整数在输出序列中被再现，随后是零值的填充。


--- a/docs/lstm/how-to-use-an-encoder-decoder-lstm-to-echo-sequences-of-random-integers.md
+++ b/docs/lstm/how-to-use-an-encoder-decoder-lstm-to-echo-sequences-of-random-integers.md
@@ -482,7 +482,7 @@ model.add(TimeDistributed(Dense(100, activation='softmax')))
 model.add(LSTM(150, return_sequences=True, stateful=True))
 ```

-这两层不能整齐地配合在一起。编码器层将输出2D阵列（21,150），并且解码器期望3D阵列作为输入（21，α，150）。
+这两层不能整齐地配合在一起。编码器层将输出2D数组（21,150），并且解码器期望3D数组作为输入（21，α，150）。

 我们通过在编码器和解码器之间添加RepeatVector（）层来解决这个问题，并确保编码器的输出重复适当的次数以匹配输出序列的长度。在这种情况下，输出序列中两个时间步长为2次。


--- a/docs/lstm/memory-in-a-long-short-term-memory-network.md
+++ b/docs/lstm/memory-in-a-long-short-term-memory-network.md
@@ -198,7 +198,7 @@ for i in range(len(X)):

 最后一步是重新整形数据，以便LSTM网络可以直接使用它。

-Keras LSTM期望输入模式（X）为具有[_样本，时间步长，特征_]维度的三维NumPy阵列。
+Keras LSTM期望输入模式（X）为具有[_样本，时间步长，特征_]维度的三维NumPy数组。

 在一个输入数据序列的情况下，维度将是[4,1,5]，因为我们有4行数据，每行有1个时间步长，每行有5列。


--- a/docs/lstm/reshape-input-data-long-short-term-memory-networks-keras.md
+++ b/docs/lstm/reshape-input-data-long-short-term-memory-networks-keras.md
@@ -56,7 +56,7 @@ model.add(Dense(1))
 *   **时间步**。一个步骤是样品中的一个观察点。
 *   **功能**。一个特征是在一个时间步骤的一个观察。

-这意味着输入层在拟合模型和做出预测时需要3D数据阵列，即使数组的特定尺寸包含单个值，例如，一个样本或一个特征。
+这意味着输入层在拟合模型和做出预测时需要3D数据数组，即使数组的特定尺寸包含单个值，例如，一个样本或一个特征。

 定义LSTM网络的输入层时，网络假定您有一个或多个样本，并要求您指定时间步数和要素数。您可以通过指定“`input_shape`”参数的元组来完成此操作。

@@ -87,7 +87,7 @@ from numpy import array
 data = array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
 ```

-然后我们可以使用NumPy阵列上的 _reshape（）_函数将这个一维数组重新整形为一个三维数组，每个时间步长有1个样本，10个时间步长和1个特征。
+然后我们可以使用NumPy数组上的 _reshape（）_函数将这个一维数组重新整形为一个三维数组，每个时间步长有1个样本，10个时间步长和1个特征。

 在数组上调用时， _reshape（）_函数接受一个参数，该参数是定义数组新形状的元组。我们不能传递任何数字元组;重塑必须均匀地重新组织数组中的数据。

@@ -95,7 +95,7 @@ data = array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
 data = data.reshape((1, 10, 1))
 ```

-重新成形后，我们可以打印阵列的新形状。
+重新成形后，我们可以打印数组的新形状。

 ```py
 print(data.shape)
@@ -208,7 +208,7 @@ model.add(Dense(1))
 *   LSTM输入层由第一个隐藏层上的`input_shape`参数定义。
 *  `input_shape`参数采用两个值的元组来定义时间步长和特征的数量。
 *   假设样本数为1或更多。
-*   NumPy阵列上的 _reshape（）_功能可用于将您的1D或2D数据重塑为3D。
+*   NumPy数组上的 _reshape（）_功能可用于将您的1D或2D数据重塑为3D。
 *   _reshape（）_函数将元组作为定义新形状的参数。

 ## 进一步阅读

--- a/docs/lstm/stacked-long-short-term-memory-networks.md
+++ b/docs/lstm/stacked-long-short-term-memory-networks.md
@@ -78,7 +78,7 @@ Graves等人介绍了堆叠的LSTM或深LSTM。在将LSTM应用于语音识别

 我们可以在Keras Python深度学习库中轻松创建Stacked LSTM模型

-每个LSTM存储器单元都需要3D输入。当LSTM处理一个输入时间步长序列时，每个存储器单元将输出整个序列的单个值作为2D阵列。
+每个LSTM存储器单元都需要3D输入。当LSTM处理一个输入时间步长序列时，每个存储器单元将输出整个序列的单个值作为2D数组。

 我们可以使用具有单个隐藏LSTM层的模型来演示以下内容，该LSTM层也是输出层。


--- a/docs/lstm/use-different-batch-sizes-training-predicting-python-keras.md
+++ b/docs/lstm/use-different-batch-sizes-training-predicting-python-keras.md
@@ -140,7 +140,7 @@ X = X.reshape(len(X), 1, 1)
 print(X.shape, y.shape)
 ```

-运行该示例创建`X`和`y`阵列，准备与LSTM一起使用并打印其形状。
+运行该示例创建`X`和`y`数组，准备与LSTM一起使用并打印其形状。

 ```py
 (9, 1, 1) (9,)

--- a/docs/ml-algo/confusion-matrix-machine-learning.md
+++ b/docs/ml-algo/confusion-matrix-machine-learning.md
@@ -206,7 +206,7 @@ no-event	false negative		true negative

 下面是在Pima Indians Diabetes数据集上训练k-最近邻算法后，来自Weka Explorer界面的屏幕截图。

-混淆矩阵列在底部，您可以看到还提供了大量的分类统计数据。
+混淆矩数组在底部，您可以看到还提供了大量的分类统计数据。

 混淆矩阵将字母a和b分配给类值，并为行提供预期的类值，并为每列提供预测的类值（“分类为”）。


--- a/docs/sklearn/a-gentle-introduction-to-scikit-learn-a-python-machine-learning-library.md
+++ b/docs/sklearn/a-gentle-introduction-to-scikit-learn-a-python-machine-learning-library.md
@@ -58,7 +58,7 @@ scikit-learn 提供的一些流行的模型组包括：
 *   **特征选择**：用于识别创建监督模型的有意义属性。
 *   **参数调整**：用于充分利用受监督的模型。
 *   **流形学习**：用于总结和描绘复杂的多维数据。
-*   **监督模型**：一个庞大的阵列，不仅限于广义线性模型，判别分析，朴素贝叶斯，惰性方法，神经网络，支持向量机和决策树。
+*   **监督模型**：一个庞大的数组，不仅限于广义线性模型，判别分析，朴素贝叶斯，惰性方法，神经网络，支持向量机和决策树。

 ## 示例：分类和回归树


--- a/docs/sklearn/crash-course-python-machine-learning-developers.md
+++ b/docs/sklearn/crash-course-python-machine-learning-developers.md
@@ -279,7 +279,7 @@ Running the example prints:

 NumPy 为 SciPy 提供基础数据结构和操作。这些是有效定义和操作的数组（ndarrays）。

-### 创建阵列
+### 创建数组

 ```
 # define an array

--- a/docs/sklearn/metrics-evaluate-machine-learning-algorithms-python.md
+++ b/docs/sklearn/metrics-evaluate-machine-learning-algorithms-python.md
@@ -195,7 +195,7 @@ matrix = confusion_matrix(Y_test, predicted)
 print(matrix)
 ```

-虽然阵列的打印没有标题，但您可以看到大多数预测都落在矩阵的对角线上（这是正确的预测）。
+虽然数组的打印没有标题，但您可以看到大多数预测都落在矩阵的对角线上（这是正确的预测）。

 ```
 [[141  21]

--- a/docs/sklearn/understand-machine-learning-data-descriptive-statistics-python.md
+++ b/docs/sklearn/understand-machine-learning-data-descriptive-statistics-python.md
@@ -214,7 +214,7 @@ correlations = data.corr(method='pearson')
 print(correlations)
 ```

-矩阵列出了顶部和侧面的所有属性，以给出所有属性对之间的相关性（两次，因为矩阵是对称的）。您可以看到矩阵左上角到右下角的矩阵对角线显示每个属性与自身的完美关联。
+矩数组出了顶部和侧面的所有属性，以给出所有属性对之间的相关性（两次，因为矩阵是对称的）。您可以看到矩阵左上角到右下角的矩阵对角线显示每个属性与自身的完美关联。

 ```
        preg   plas   pres   skin   test   mass   pedi    age  class

--- a/docs/sklearn/using-opencv-python-and-template-matching-to-play-wheres-waldo.md
+++ b/docs/sklearn/using-opencv-python-and-template-matching-to-play-wheres-waldo.md
@@ -240,7 +240,7 @@ cv2.imshow("Waldo", waldo)
 cv2.waitKey(0)
 ```

-在这里，我们只是使用 **Line 37** 上的一些 NumPy 阵列切片技术将 Waldo ROI 重新放回到原始图像中。什么都没有。
+在这里，我们只是使用 **Line 37** 上的一些 NumPy 数组切片技术将 Waldo ROI 重新放回到原始图像中。什么都没有。

 最后，**第 40-42 行**通过在屏幕上显示我们的 Waldo 查询和拼图图像并等待按键来显示我们的工作结果。


--- a/docs/stat/a-gentle-introduction-to-calculating-normal-summary-statistics.md
+++ b/docs/stat/a-gentle-introduction-to-calculating-normal-summary-statistics.md
@@ -197,7 +197,7 @@ mean = sum(data) / length(data)
 mean = 1 / length(data) * sum(data)
 ```

-我们可以通过在阵列上使用`mean()`NumPy函数来计算样本的平均值。
+我们可以通过在数组上使用`mean()`NumPy函数来计算样本的平均值。

 ```py
 result = mean(data)

--- a/docs/ts-intro/autoregression-models-time-series-forecasting-python.md
+++ b/docs/ts-intro/autoregression-models-time-series-forecasting-python.md
@@ -358,7 +358,7 @@ Test MSE: 1.502

 另一种方法是使用学习的系数并手动做出预测。这要求保留 29 个先前观察的历史，并且从模型中检索系数并在回归方程中使用以得出新的预测。

-系数以阵列形式提供，截距项后跟每个滞后变量的系数，从 t-1 到 t-n 开始。我们只需要按照正确的顺序在观察历史中使用它们，如下所示：
+系数以数组形式提供，截距项后跟每个滞后变量的系数，从 t-1 到 t-n 开始。我们只需要按照正确的顺序在观察历史中使用它们，如下所示：

 ```py
 yhat = b0 + b1*X1 + b2*X2 ... bn*Xn

--- a/docs/ts-intro/python-environment-time-series-forecasting.md
+++ b/docs/ts-intro/python-environment-time-series-forecasting.md
@@ -55,7 +55,7 @@ Python 机器学习工作与 R 机器学习工作

 [pandas 库](http://pandas.pydata.org)提供了用于在 Python 中加载和处理数据的高表现工具。

-它建立在 SciPy 生态系统的基础上，主要使用 NumPy 阵列，但提供方便易用的数据结构，如`DataFrame`和 _ 系列 _，用于表示数据。
+它建立在 SciPy 生态系统的基础上，主要使用 NumPy 数组，但提供方便易用的数据结构，如`DataFrame`和 _ 系列 _，用于表示数据。

 Pandas 提供[特别关注对时间序列数据的支持](http://pandas.pydata.org/pandas-docs/stable/timeseries.html)。

@@ -70,7 +70,7 @@ Pandas 提供[特别关注对时间序列数据的支持](http://pandas.pydata.o

 [statsmodels 库](http://statsmodels.sourceforge.net/)提供统计建模工具。

-它建立在 SciPy 生态系统的基础上，并支持 NumPy 阵列和 Pandas _ 系列 _ 对象形式的数据。
+它建立在 SciPy 生态系统的基础上，并支持 NumPy 数组和 Pandas _ 系列 _ 对象形式的数据。

 它提供了一套统计测试和建模方法，以及专用于时间序列分析的[工具，它们也可用于预测。](http://statsmodels.sourceforge.net/stable/tsa.html)