如何为机器学习索引、切片和重塑 NumPy 数组

作者： Jason Brownlee 发布于 2020 年 6 月 13 日所属分类：线性代数 102

机器学习数据以数组形式表示。

在 Python 中，数据几乎普遍以 NumPy 数组的形式表示。

如果您是 Python 新手，可能会对一些访问数据的 Pythonic 方式感到困惑，例如负索引和数组切片。

在本教程中，您将学习如何在 NumPy 数组中正确操作和访问数据。

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

如何将列表数据转换为 NumPy 数组。
如何使用 Pythonic 索引和切片访问数据。
如何调整数据大小以满足某些机器学习 API 的期望。

通过我的新书《机器学习的线性代数》启动您的项目，包括分步教程和所有示例的 Python 源代码文件。

让我们开始吧。

2019 年 7 月更新：修复了与重塑 1D 数据相关的微小拼写错误（感谢 Rodrigue）。

How to Index, Slice and Reshape NumPy Arrays for Machine Learning in Python

如何在 Python 中为机器学习索引、切片和重塑 NumPy 数组
图片由 Björn Söderqvist 提供，保留部分权利。

教程概述

本教程分为4个部分，它们是：

从列表到数组
数组索引
数组切片
数组重塑

在机器学习线性代数方面需要帮助吗？

立即参加我为期7天的免费电子邮件速成课程（附示例代码）。

点击注册，同时获得该课程的免费PDF电子书版本。

1. 从列表到数组

一般来说，我建议使用 Pandas 甚至 NumPy 函数从文件加载数据。

有关示例，请参阅帖子

如何在 Python 中加载机器学习数据

本节假设您已通过其他方式加载或生成了数据，并且现在数据以 Python 列表的形式表示。

让我们看看如何将列表中的数据转换为 NumPy 数组。

一维列表到数组

您可能会加载或生成数据并以列表形式访问它。

您可以通过调用 array() NumPy 函数将一维数据列表转换为数组。

# one dimensional example
from numpy import array
# list of data
data = [11, 22, 33, 44, 55]
# array of data
data = array(data)
print(data)
print(type(data))

# 一维示例

from numpy import array

# 数据列表

data = [11, 22, 33, 44, 55]

# 数据数组

data = array(data)

print(data)

print(type(data))

运行示例将一维列表转换为 NumPy 数组。

[11 22 33 44 55]
<class 'numpy.ndarray'>

1 2	[11 22 33 44 55] <class 'numpy.ndarray'>

二维列表到数组

在机器学习中，您更可能拥有二维数据。

这是一个数据表，其中每一行代表一个新的观测值，每一列代表一个新的特征。

也许您使用自定义代码生成或加载了数据，现在您有一个列表的列表。每个列表都代表一个新的观测值。

您可以通过调用 array() 函数，以与上述相同的方式将列表的列表转换为 NumPy 数组。

# two dimensional example
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print(data)
print(type(data))

# 二维示例

from numpy import array

# 数据列表

data = [[11, 22],

[33, 44],

[55, 66]]

# 数据数组

data = array(data)

print(data)

print(type(data))

运行示例显示数据已成功转换。

[[11 22]
 [33 44]
 [55 66]]
<class 'numpy.ndarray'>

[[11 22]

[33 44]

[55 66]]

2. 数组索引

一旦您的数据以 NumPy 数组的形式表示，您就可以使用索引来访问它。

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

一维索引

一般来说，索引的工作方式与您在其他编程语言（如 Java、C# 和 C++）中的经验预期相同。

例如，您可以使用方括号运算符 [] 访问元素，指定要检索的值的零偏移索引。

# simple indexing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
# index data
print(data[0])
print(data[4])

# 简单索引

from numpy import array

# 定义数组

data = array([11, 22, 33, 44, 55])

# 索引数据

print(data[0])

print(data[4])

运行示例打印数组中的第一个和最后一个值。

11
55

指定超出数组边界的过大整数将导致错误。

# simple indexing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
# index data
print(data[5])

# 简单索引

from numpy import array

# 定义数组

data = array([11, 22, 33, 44, 55])

# 索引数据

print(data[5])

运行示例打印以下错误

IndexError: index 5 is out of bounds for axis 0 with size 5

1	IndexError: index 5 is out of bounds for axis 0 with size 5

一个关键区别是您可以使用负索引来检索相对于数组末尾偏移的值。

例如，索引 -1 指的是数组中的最后一个项目。索引 -2 返回倒数第二个项目，一直到当前示例中的第一个项目的 -5。

# simple indexing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
# index data
print(data[-1])
print(data[-5])

# 简单索引

from numpy import array

# 定义数组

data = array([11, 22, 33, 44, 55])

# 索引数据

print(data[-1])

print(data[-5])

运行示例打印数组中的最后一个和第一个项目。

55
11

二维索引

索引二维数据与索引一维数据类似，只是使用逗号分隔每个维度的索引。

data[0,0]

数据[0,0]

这与基于 C 的语言不同，在这些语言中，每个维度都使用单独的方括号运算符。

data[0][0]

数据[0][0]

例如，我们可以按如下方式访问第一行和第一列

# 2d indexing
from numpy import array
# define array
data = array([[11, 22], [33, 44], [55, 66]])
# index data
print(data[0,0])

# 2d 索引

from numpy import array

# 定义数组

data = array([[11, 22], [33, 44], [55, 66]])

# 索引数据

print(data[0,0])

运行示例打印数据集中第一个项目。

11

如果我们对第一行中的所有项目感兴趣，我们可以将第二个维度索引留空，例如

# 2d indexing
from numpy import array
# define array
data = array([[11, 22], [33, 44], [55, 66]])
# index data
print(data[0,])

# 2d 索引

from numpy import array

# 定义数组

data = array([[11, 22], [33, 44], [55, 66]])

# 索引数据

print(data[0,])

这将打印第一行数据。

[11 22]

[11 22]

3. 数组切片

到目前为止，一切顺利；创建和索引数组看起来很熟悉。

现在我们来看数组切片，这是 Python 和 NumPy 数组初学者会遇到问题的一个特性。

列表和 NumPy 数组等结构可以进行切片。这意味着可以索引和检索结构的子序列。

这在机器学习中指定输入变量和输出变量，或将训练行与测试行分开时最有用。

切片使用冒号运算符“:”指定，并在冒号前后分别带有“from”和“to”索引。切片从“from”索引开始，在“to”索引之前的一个项目处结束。

data[from:to]

1	data[from:to]

让我们看一些例子。

一维切片

您可以通过指定没有索引的切片“:”来访问数组维度中的所有数据。

# simple slicing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data[:])

# 简单切片

from numpy import array

# 定义数组

data = array([11, 22, 33, 44, 55])

print(data[:])

运行示例打印数组中的所有元素。

[11 22 33 44 55]

1	[11 22 33 44 55]

数组的第一个项目可以通过指定从索引 0 开始到索引 1 结束（“to”索引前一个项目）的切片来切片。

# simple slicing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data[0:1])

# 简单切片

from numpy import array

# 定义数组

data = array([11, 22, 33, 44, 55])

print(data[0:1])

运行示例返回一个包含第一个元素的子数组。

[11]

[11]

我们也可以在切片中使用负索引。例如，我们可以通过从 -2（倒数第二个项目）开始切片而不指定“to”索引来切片列表中的最后两个项目；这将切片一直到维度的末尾。

# simple slicing
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data[-2:])

# 简单切片

from numpy import array

# 定义数组

data = array([11, 22, 33, 44, 55])

print(data[-2:])

运行示例返回一个仅包含最后两个项目的子数组。

[44 55]

[44 55]

二维切片

让我们看看您在机器学习中最可能使用的两个二维切片示例。

拆分输入和输出特征

通常将加载的数据拆分为输入变量 (X) 和输出变量 (y)。

我们可以通过切片所有行和所有列直到（但不包括）最后一列，然后单独索引最后一列来实现此目的。

对于输入特征，我们可以通过在行索引中指定“:”，在列索引中指定 :-1 来选择除最后一列外的所有行和所有列。

X = [:, :-1]

1	X = [:, :-1]

对于输出列，我们可以再次使用“:”选择所有行，并通过指定 -1 索引仅索引最后一列。

y = [:, -1]

1	y = [:, -1]

将所有这些放在一起，我们可以将一个 3 列的 2D 数据集分离为输入和输出数据，如下所示

# split input and output
from numpy import array
# define array
data = array([[11, 22, 33],
		[44, 55, 66],
		[77, 88, 99]])
# separate data
X, y = data[:, :-1], data[:, -1]
print(X)
print(y)

# 拆分输入和输出

from numpy import array

# 定义数组

data = array([[11, 22, 33],

[44, 55, 66],

[77, 88, 99]])

# 分离数据

X, y = data[:, :-1], data[:, -1]

print(X)

print(y)

运行示例打印分离的 X 和 y 元素。请注意，X 是一个 2D 数组，y 是一个 1D 数组。

[[11 22]
 [44 55]
 [77 88]]
[33 66 99]

[[11 22]

[44 55]

[77 88]]

[33 66 99]

拆分训练和测试行

通常将加载的数据集拆分为单独的训练集和测试集。

这是行的拆分，其中一部分将用于训练模型，其余部分将用于估计训练模型的技能。

这将涉及通过在第二个维度索引中指定“:”来切片所有列。训练数据集将是从开始到分割点的所有行。

dataset
train = data[:split, :]

1 2	数据集 train = data[:split, :]

测试数据集将是从分割点到维度末尾的所有行。

test = data[split:, :]

1	test = data[split:, :]

将所有这些放在一起，我们可以将数据集在设定的分割点 2 处拆分。

# split train and test
from numpy import array
# define array
data = array([[11, 22, 33],
		[44, 55, 66],
		[77, 88, 99]])
# separate data
split = 2
train,test = data[:split,:],data[split:,:]
print(train)
print(test)

# 拆分训练和测试

from numpy import array

# 定义数组

data = array([[11, 22, 33],

[44, 55, 66],

[77, 88, 99]])

# 分离数据

split = 2

train,test = data[:split,:],data[split:,:]

print(train)

print(test)

运行示例选择前两行进行训练，最后一行用于测试集。

[[11 22 33]
[44 55 66]]
[[77 88 99]]

[[11 22 33]

[44 55 66]]

[[77 88 99]]

4. 数组重塑

切片数据后，您可能需要重塑它。

例如，某些库（例如 scikit-learn）可能要求将一维输出变量数组 (y) 重塑为具有一列和每行结果的二维数组。

一些算法，例如 Keras 中的长短期记忆循环神经网络，要求将输入指定为由样本、时间步和特征组成的三维数组。

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

数据形状

NumPy 数组有一个 shape 属性，该属性返回一个表示数组每个维度长度的元组。

例如：

# array shape
from numpy import array
# define array
data = array([11, 22, 33, 44, 55])
print(data.shape)

# 数组形状

from numpy import array

# 定义数组

data = array([11, 22, 33, 44, 55])

print(data.shape)

运行示例打印一维的元组。

(5,)

(5,)

对于二维数组，将返回一个包含两个长度的元组。

# array shape
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print(data.shape)

# 数组形状

from numpy import array

# 数据列表

data = [[11, 22],

[33, 44],

[55, 66]]

# 数据数组

data = array(data)

print(data.shape)

运行示例返回一个包含行数和列数的元组。

(3, 2)

(3, 2)

您可以在形状维度中使用数组维度的尺寸，例如指定参数。

元组的元素可以像数组一样访问，其中第 0 个索引表示行数，第 1 个索引表示列数。例如

# array shape
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print('Rows: %d' % data.shape[0])
print('Cols: %d' % data.shape[1])

# 数组形状

from numpy import array

# 数据列表

data = [[11, 22],

[33, 44],

[55, 66]]

# 数据数组

data = array(data)

print('行数: %d' % data.shape[0])

print('列数: %d' % data.shape[1])

运行示例访问每个维度的特定大小。

Rows: 3
Cols: 2

1 2	行数: 3 列数: 2

将 1D 重塑为 2D 数组

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

NumPy 在 NumPy 数组对象上提供了 reshape() 函数，可用于重塑数据。

reshape() 函数接受一个参数，该参数指定数组的新形状。在将一维数组重塑为具有一列的二维数组的情况下，元组将是数组形状作为第一个维度 (data.shape[0])，第二个维度为 1。

data = data.reshape((data.shape[0], 1))

1	data = data.reshape((data.shape[0], 1))

将所有这些放在一起，我们得到以下工作示例。

# reshape 1D array
from numpy import array
from numpy import reshape
# define array
data = array([11, 22, 33, 44, 55])
print(data.shape)
# reshape
data = data.reshape((data.shape[0], 1))
print(data.shape)

# 重塑 1D 数组

from numpy import array

from numpy import reshape

# 定义数组

data = array([11, 22, 33, 44, 55])

print(data.shape)

# 重塑

data = data.reshape((data.shape[0], 1))

print(data.shape)

运行示例打印一维数组的形状，将数组重塑为 5 行 1 列，然后打印此新形状。

(5,)
(5, 1)

1 2	(5,) (5, 1)

将 2D 重塑为 3D 数组

通常需要将二维数据（其中每一行代表一个序列）重塑为三维数组，以供需要多个样本、一个或多个时间步和一个或多个特征的算法使用。

一个很好的例子是 Keras 深度学习库中的 LSTM 循环神经网络模型。

可以直接使用 reshape 函数，指定新的维度。这在每个序列有多个时间步，每个时间步有一个观测值（特征）的示例中很清楚。

我们可以使用数组的 shape 属性中的大小来指定样本数（行）和列数（时间步），并将特征数固定为 1。

data.reshape((data.shape[0], data.shape[1], 1))

1	data.reshape((data.shape[0], data.shape[1], 1))

将所有这些放在一起，我们得到以下工作示例。

# reshape 2D array
from numpy import array
# list of data
data = [[11, 22],
		[33, 44],
		[55, 66]]
# array of data
data = array(data)
print(data.shape)
# reshape
data = data.reshape((data.shape[0], data.shape[1], 1))
print(data.shape)

# 重塑 2D 数组

from numpy import array

# 数据列表

data = [[11, 22],

[33, 44],

[55, 66]]

# 数据数组

data = array(data)

print(data.shape)

# 重塑

data = data.reshape((data.shape[0], data.shape[1], 1))

print(data.shape)

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

(3, 2)
(3, 2, 1)

1 2	(3, 2) (3, 2, 1)

进一步阅读

如果您想深入了解此主题，本节提供了更多资源。

总结

在本教程中，您学习了如何使用 Python 在 NumPy 数组中访问和重塑数据。

具体来说，你学到了：

如何将列表数据转换为 NumPy 数组。
如何使用 Pythonic 索引和切片访问数据。
如何调整数据大小以满足某些机器学习 API 的期望。

你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。

关于此主题的更多信息

Keras 中 LSTM 的返回序列和返回状态之间的区别

如何在 Keras 中开发用于神经机器翻译的 Seq2Seq 模型

对如何为机器学习索引、切片和重塑 NumPy 数组的 102 条回复

ltshan 2017 年 10 月 27 日下午 12:58 #

很棒的文章。虽然使用 python 一段时间了，但仍然学到了很多基础知识。

回复
- Jason Brownlee 2017 年 10 月 27 日下午 2:57 #
  
  很高兴它有帮助！
  
  回复
Ben 2018 年 1 月 8 日下午 7:53 #

关于将一维数组转换为矩阵形式（2D），我有一个疑问。为什么我们必须在机器学习中将 1D 转换为 2D？

回复
- Jason Brownlee 2018 年 1 月 9 日上午 5:27 #
  
  大多数机器学习算法期望矩阵作为输入，其中每一行是一个观测值。
  
  回复
Anthony The Koala 2018 年 3 月 24 日上午 8:53 #

尊敬的 Jason 博士，:,
感谢您提供此切片教程。它肯定会帮助我理解您页面上的 LSTM 材料和您的电子书。

我的问题是关于 2-D 切片和切片方法。我想要一个“广义”的切片概念。
在一维切片中，数组可以拆分为
myarray[from:to] – 这已理解

在二维切片中，“拆分输入和输出特征”部分，您给出了两个拆分的例子
x = [ : , :-1]
y = [ : , -1]

请在 myarray[from:to] 的上下文中澄清，特别是对于 2D 切片，尤其是有两个冒号“:”的情况

myarray[from: to] 和 x [ : , : -1] 对于 x，to = : ，from = : – 1，

谢谢你，
新南威尔士州的安东尼

回复
- Jason Brownlee 2018 年 3 月 25 日上午 6:24 #
  
  好问题，安东尼！
  
  当您只提供一个索引而不是切片时，比如 -1，它将只选择该列/行，在本例中是最后一列。
  
  这有帮助吗？
  
  回复
Ashish K S Arya 2018 年 4 月 27 日下午 5:53 #

你好；
感谢如此精彩的教程，我是 numpy 的新手。当我正在处理深度学习算法时，在程序的某个时刻，我需要创建一个 (1000,256,256,3) 维度的数组，其中可以加载 1000 张图像数据（大小为 256*256*3）。

您能否帮助我在 Python 中实现此功能。

代码如下

x_train=np.empty([256,256,3])

for i in range(0,1000)

pic= Image.open(f'{path}%s.jpg’ %i)

pic=pic.resize([256,256])

x_train2= np.asarray(pic)

x_train=np.stack((x_train,x_train2))

print(x_train.shape)

谢谢

回复
- Jason Brownlee 2018 年 4 月 28 日上午 5:25 #
  
  一个很好的技巧是将数据加载到列表中，将列表转换为数组，然后将数组重塑为所需的维度。
  
  回复
Fatemeh 2018 年 6 月 8 日上午 6:01 #

太棒了。这是我见过的最好的描述。

回复
- Jason Brownlee 2018 年 6 月 8 日上午 6:18 #
  
  谢谢，很高兴对您有帮助。
  
  回复
Visalini 2018 年 8 月 25 日下午 4:37 #

嗨，Jason，
如何将 3D 数组转换为 1D 数组？

请帮助我..

回复
- Jason Brownlee 2018 年 8 月 26 日上午 6:23 #
  
  X = X.reshape((X.shape[0], X.shappe[1], 1))
  
  回复
- hashim 2020 年 7 月 30 日上午 12:40 #
  
  X=X.reshape((X.shape[0]*X.shape[1]*X.shape[2],1))
  
  回复
SkrewEverything 2018 年 8 月 25 日下午 5:34 #

我们可以像 C 语言一样访问 2D 数组：data[0][0]。

使用 data[0, 0] 并不是你所说的唯一方式。

你使用的是哪个版本的 python？

回复
- Jason Brownlee 2018 年 8 月 26 日上午 6:24 #
  
  使用 [i, j] 对于 Python 2 和 3 中的 2d numpy 数组访问是有效的。
  
  回复
  - jerico 2019 年 4 月 23 日下午 4:53 #
    
    先生，您能帮我这个忙吗？您的帮助将不胜感激。提前感谢！
    
    https://stackoverflow.com/questions/55645616/how-to-output-masks-using-vis-util-visualize-boxes-and-labels-on-image-array
    
    回复
    - Jason Brownlee 2019 年 4 月 24 日上午 7:52 #
      
      您能用一两句话概括一下问题吗？
      
      回复
ai 2018 年 10 月 1 日上午 3:58 #

我找这个信息找了很久。非常非常感谢您，先生

回复
- Jason Brownlee 2018 年 10 月 1 日上午 6:30 #
  
  不客气！
  
  回复
Haotian Wang 2018 年 10 月 8 日上午 5:52 #

Jason，你帮了我很多

回复
- Jason Brownlee 2018 年 10 月 8 日上午 9:29 #
  
  很高兴它有帮助。
  
  回复
Maijama'a 2018 年 10 月 27 日下午 9:37 #

非常感谢您的这份清晰的教程。

回复
- Jason Brownlee 2018 年 10 月 28 日上午 6:10 #
  
  很高兴它有帮助。
  
  回复
RasmusT 2019 年 1 月 29 日上午 6:42 #

你好，我正在处理 3d 时间序列数据的归一化问题。

我有 3d 时间序列数据（样本、特征、时间步）。

我应该如何重塑我的 3d 数据进行归一化？
我猜是这样的
从 [样本、特征、时间步] 到 ([时间步、特征] 或 [特征、时间步])，然后使用 MinMaxScaler 对训练数据进行 fit_transform，然后对测试数据进行 transform？

回复
- Jason Brownlee 2019 年 1 月 29 日上午 11:39 #
  
  对于所有样本的每个时间序列进行归一化是个好主意。
  
  我在这里给出例子
  https://machinelearning.org.cn/machine-learning-data-transforms-for-time-series-forecasting/
  
  回复
Mansoor 2019 年 2 月 4 日下午 7:13 #

非常感谢您提供这份非常有用的、易于理解的 NumPy 数组入门教程。它非常有帮助。

回复
- Jason Brownlee 2019 年 2 月 5 日上午 8:14 #
  
  谢谢，很高兴对您有帮助。
  
  回复
Kuruvilla Abraham 2019 年 2 月 8 日下午 2:24 #

你好 jason,

我的数据框包含非图像数据，维度为 (1446736, 11)。

如何重塑此数组以馈入 CNN 模型

回复
- Jason Brownlee 2019 年 2 月 9 日上午 5:52 #
  
  这可能有帮助
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
  - Kuruvilla Abraham 2019 年 2 月 9 日下午 4:41 #
    
    谢谢 Jason，这适用于 CNN 模型以及 LSTM 吗？
    
    回复
    - Jason Brownlee 2019 年 2 月 10 日上午 9:40 #
      
      是的。
      
      回复
Eva 2019 年 4 月 9 日下午 8:00 #

嗨 Jason，感谢您的教程，它确实有助于巩固基础知识。
我有一个有点相关的问题——numpy reshape 函数的默认重塑顺序是 C。在 Keras 中工作时，使用 numpy reshape 或 Keras 原生 reshape 有什么区别吗？它使用相同的顺序吗？如果不是，是否可以直接在 Keras 代码中使用 numpy 原生函数？

谢谢！ 🙂

回复
- Jason Brownlee 2019 年 4 月 10 日上午 6:11 #
  
  它们解决不同的问题。
  
  您可以使用 numpy 重塑数组。
  
  Keras 提供了一个重塑层，用于重塑作为神经网络一部分的张量。
  
  回复
Rahul 2019 年 4 月 13 日下午 5:37 #

你真棒！解释得太好了。谢谢！

回复
- Jason Brownlee 2019 年 4 月 14 日上午 5:44 #
  
  谢谢，很高兴对您有帮助。
  
  回复
Nastaran 2019 年 4 月 26 日上午 11:26 #

你好，

只是想知道如何导入一个 2D 数组数据集？

谢谢

回复
- Jason Brownlee 2019 年 4 月 26 日下午 1:57 #
  
  你的意思是文件加载吗？
  
  这个可能会有帮助
  https://machinelearning.org.cn/load-machine-learning-data-python/
  
  回复
dong zhan 2019 年 5 月 27 日下午 12:32 #

您非常周到地提供了这个教程，否则，我很难遵循您的机器学习教程，非常感谢

回复
- Jason Brownlee 2019 年 5 月 27 日下午 2:38 #
  
  谢谢，很高兴对您有帮助。
  
  回复
Sandeep Dawre 2019 年 6 月 5 日下午 7:51 #

最棒的文章之一！！

回复
- Jason Brownlee 2019 年 6 月 6 日上午 6:22 #
  
  谢谢！
  
  回复
Hemanth 2019 年 6 月 18 日上午 4:24 #

先生，非常感谢您的这篇文章。

回复
- Jason Brownlee 2019 年 6 月 18 日上午 6:42 #
  
  不客气。
  
  回复
Rodrigue KANKEU 2019 年 7 月 2 日下午 5:21 #

嗨 Jason，再次感谢您提供这个精彩的教程。我在第 4 节关于重塑的以下句子中遇到问题。
例如，某些库（如 scikit-learn）可能要求将一维输出变量 (y) 数组重塑为具有一列和每列结果的二维数组。

我不太明白，是不是？
例如，某些库（如 scikit-learn）可能要求将一维输出变量 (y) 数组重塑为具有一列和每“行”结果的二维数组。
事实上，我很困惑。
非常感谢您所做的工作。

回复
- Jason Brownlee 2019 年 7 月 3 日上午 8:24 #
  
  是的，我指的是行。已更新。
  
  是的，所以 [1, 2, 3] 是一个形状为 (3,) 的 1D 数组，它变成 [[1, 2, 3]]，或者是一个具有 3 行形状 (1,3) 的一列。
  
  回复
Rakesh 2019 年 7 月 24 日下午 2:57 #

尊敬的先生，我想将我的 tfidf 向量（形状为 156060×15103）输入到 LSTM 层，其中包含 150 个时间序列步和 15103 个特征。我的 LSTM 输入应该看起来像 (None, 150, 15103)。我该如何实现这一点？请帮助我。
如果数组重塑在此处没有帮助，请提出任何替代方法，说明如何使用 tfidf 输入创建 (None, 150, 15103) 的 LSTM 层。

我的目标是将 tfidf 输出作为 LSTM 层的输入，其中包含 150 个时间步。
我的目标是将 tfidf 输出作为 LSTM 层的输入，其中包含 150 个时间步。

请帮忙。

回复
- Jason Brownlee 2019 年 7 月 25 日上午 7:39 #
  
  在第一个 LSTM 层上设置 input_shape 参数为所需形状。
  
  回复
tina 2019 年 8 月 15 日下午 7:08 #

如何让用户输入 3D 并将其作为逆向求解

回复
- Jason Brownlee 2019 年 8 月 16 日上午 7:50 #
  
  抱歉，我没明白。你能详细说明一下吗？
  
  回复
Nick 2019 年 8 月 28 日下午 9:46 #

嗨，Jason，

我遇到了一些奇怪的索引问题，我似乎有正确的坐标来调用 `cv2.rectangle()` 和 `plt.Rectangle()`，但使用相同的坐标进行切片却不起作用，即 y1 和 y2 需要反转。我在 OpenCV Github 上有一个问题，但如果您有空，能看一眼吗？ https://github.com/opencv/opencv/issues/15406

回复
- Jason Brownlee 2019 年 8 月 29 日上午 6:07 #
  
  很抱歉听到这个消息，这听起来像是一个 opencv 问题，而不是 python 数组问题。
  
  祝你好运。
  
  回复
Ipsita 2019 年 10 月 10 日下午 6:18 #

我有一个 .dat 文件，其中包含矩阵图像，大小为 784x1990，即总共有 1990 张图像，矩阵的每一列对应一张大小为 28x28 像素的图像。如何将其可视化。请帮助。
矩阵对应一张大小为 28x28 像素的图像。如何将其可视化。请帮助。

回复
- Jason Brownlee 2019 年 10 月 11 日上午 6:15 #
  
  也许这会有帮助。
  https://machinelearning.org.cn/how-to-load-and-manipulate-images-for-deep-learning-in-python-with-pil-pillow/
  
  回复
Abdoo 2019 年 10 月 13 日下午 6:55 #

很棒的文章！

我有一个要输入到堆叠 LSTM 的数据。数据形状为 (81,25,12)。当我使用 model.predict 进行预测时，输出当然会再次是 3D (81,25,12)。但我想单独绘制每个特征。我想将输出转换回 2D 并切片每个列/特征以进行误差计算和绘图。

如何将 3D 转换回 2D 数组？
非常感谢 Jason！

回复
- Jason Brownlee 2019 年 10 月 14 日上午 8:06 #
  
  输出不必是 3d，输出可以是您模型中设计的任何形状。
  
  尽管如此，您可以使用 reshape() 函数重塑数组
  
  数据 = 数据.reshape((??))
  
  回复
Ryan 2019 年 10 月 16 日上午 3:58 #

嗨，Jason，

您能解释一下 2D 数组的数组切片，例如 [:,:,1] 吗？

回复
- Jason Brownlee 2019 年 10 月 16 日上午 8:11 #
  
  是的，它选择所有行和第 0 列。
  
  回复
shadrack kodondi 2019 年 10 月 17 日上午 1:37 #

这是我遇到过的最好的机器学习培训……谢谢

回复
- Jason Brownlee 2019 年 10 月 17 日上午 6:39 #
  
  谢谢。
  
  回复

Anthony The Koala 2019 年 11 月 15 日上午 9:44 #

尊敬的Jason博士，
在“二维切片”标题下

它写道
“对于输入特征，我们可以选择除最后一列外的所有行和列，通过…”

澄清一下
“对于输入特征，我们可以选择除最后一列外的所有行和所有列，通过…”

X = [:,:-1]

1	X = [:,:-1]

它写道
“对于输出列，我们可以再次使用”选择所有行
并只索引最后一列，通过…”

澄清一下
“对于输出列，我们可以再次使用”选择所有行
并只索引最后一行，通过…”

y = [:,-1]

1	y = [:,-1]

原因是，在最后一个示例中，显示了最后一行的所有列。

或者，只显示最后一行。

谢谢你，
悉尼的Anthony

Anthony The Koala 2019 年 11 月 15 日上午 10:04 #

尊敬的Jason博士，
我对第 2 节的进一步阐述

import numpy as np

doo = np.array([[1,2,3],[4,5,6],[7,8,9]])
doo
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

#Select only the all rows and all columns except the last column
doo[:,:-1]
array([[1, 2],
       [4, 5],
       [7, 8]])

#Select only all the rows and all columns except the last two columns
doo[:,:-2]
array([[1],
       [4],
       [7]])

#Select all rows and last column
doo[:,-1]
array([3, 6, 9])

#Select all rows and second column
doo[:,-2]
array([2, 5, 8])

#Select all rows and first column
doo[:,0]
array([1, 4, 7])

import numpy as np

doo = np.array([[1,2,3],[4,5,6],[7,8,9]])

doo

array([[1, 2, 3],

[4, 5, 6],

[7, 8, 9]])

#仅选择所有行和除最后一列外的所有列

doo[:,:-1]

array([[1, 2],

[4, 5],

[7, 8]])

#仅选择所有行和除最后两列外的所有列

doo[:,:-2]

array([[1],

[4],

[7]])

#选择所有行和最后一列

doo[:,-1]

array([3, 6, 9])

#选择所有行和第二列

doo[:,-2]

array([2, 5, 8])

#选择所有行和第一列

doo[:,0]

array([1, 4, 7])

#选择所有行和前两列
doo[:,0:2]
array([[1, 2],
[4, 5],
[7, 8]])

列表并非详尽无遗，但通过实验您可以更好地理解。

谢谢你，
悉尼的Anthony

Anthony The Koala 2019 年 11 月 15 日上午 11:18 #

尊敬的Jason博士，
虽然上述方法着眼于选择“连续”的行或列，但最后的接触是选择特定的列或特定的行。

#The whole matrix
doo	       
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

#Select the first and last (3rd row)
doo[[0,2],:]
array([[1, 2, 3],
       [7, 8, 9]])

#Select the first and last columns
doo[:,[0,2]]	       
array([[1, 3],
       [4, 6],
       [7, 9]])

#If you want the diagonal of the matrix, use numpy's diag = no clever indexing
np.diag(doo)
array([1, 5, 9])

# 整个矩阵

doo

array([[1, 2, 3],

[4, 5, 6],

[7, 8, 9]])

# 选择第一行和最后一行（第 3 行）

doo[[0,2],:]

array([[1, 2, 3],

[7, 8, 9]])

# 选择第一列和最后一列

doo[:,[0,2]]

array([[1, 3],

[4, 6],

[7, 9]])

# 如果您想要矩阵的对角线，请使用 numpy 的 diag = 没有巧妙的索引

np.diag(doo)

array([1, 5, 9])

仍在探索矩阵选择的基础知识，

请问一个问题
如果你有一个 3D 矩阵，如何切片一个矩阵。

谢谢你
悉尼的Anthony

Jason Brownlee 2019 年 11 月 16 日上午 7:17 #

熟练掌握 Python 中的切片很重要。

回复

Jason Brownlee 2019 年 11 月 16 日上午 7:16 #

干得好！

回复

Jason Brownlee 2019 年 11 月 16 日上午 7:16 #

谢谢。

Anthony The Koala 2019 年 11 月 20 日上午 1:33 #

尊敬的Jason博士，
我尝试了切片 3D 数组。我能够选择特定的列和特定的行。我不知道 3D 数组是否被切片，或者切片 3D 数组是否有应用。所以这里是。

我注意到切片技术并非详尽无遗。

doo = [1 + i for i in range(36)]
doo = np.reshape(doo,[3,3,4])
# We relate all examples from the 3x3x4 array
doo; # We could also say doo[:]
array([[[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]],

       [[13, 14, 15, 16],
        [17, 18, 19, 20],
        [21, 22, 23, 24]],

       [[25, 26, 27, 28],
        [29, 30, 31, 32],
        [33, 34, 35, 36]]])

doo[0,]    # Oth submatrix (the first)
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

doo[1,]    # 1st submatrix (the second)
array([[13, 14, 15, 16],
       [17, 18, 19, 20],
       [21, 22, 23, 24]])

doo[2,]    # 2nd submatrix (the third)
array([[25, 26, 27, 28],
       [29, 30, 31, 32],
       [33, 34, 35, 36]])

doo[0:,0] ;# The first row (0th) of each submatrix
array([[ 1,  2,  3,  4],
       [13, 14, 15, 16],
       [25, 26, 27, 28]])

doo[0:,1] ;# The second row (1st) of each submatrix
array([[ 5,  6,  7,  8],
       [17, 18, 19, 20],
       [29, 30, 31, 32]])

doo[0:,2] ;# The third row (2nd) of each submatrix
array([[ 9, 10, 11, 12],
       [21, 22, 23, 24],
       [33, 34, 35, 36]])

#Getting specific columns for a particular submatrix
#doo[submatrix,[array of rows], column]\

doo[0,[0,1,2],0] #1st submatrix, rows 0-2, 0th column, that is first column of first submatrix
array([1, 5, 9])

doo[0,[0,1,2],1] #1st submatrix, rows 0-2, 0th column, that is the 2nd column of first submatrix
array([ 2,  6, 10])

doo[1,[0,1,2],0] #2nd submatrix, rows 0-2, 0th column, that is the 1st column of 2nd submatrix
array([13, 17, 21])

doo[1,[0,1,2],1]  #2nd submatrix rows 0-2, 1st column, that is the 2nd column of 2nd submatrix
array([14, 18, 22])

#Specific columns of all submatrices 3x3 -please relate this to the 3x4x3 matrix
doo[:,:,0] #First column of all submatrices
array([[ 1,  5,  9],
       [13, 17, 21],
       [25, 29, 33]])

doo[:,:,1] #Second column of all submatrices
array([[ 2,  6, 10],
       [14, 18, 22],
       [26, 30, 34]])

#doo[:,:,2] #Third column of all submatrices
#doo[:,:,3] #Fourth column of all submatrices

#Selecting multiple columns
#Example 1st and 2nd columns of each submatrix
doo[:,:,[0,1]]
array([[[ 1,  2],
        [ 5,  6],
        [ 9, 10]],

       [[13, 14],
        [17, 18],
        [21, 22]],

       [[25, 26],
        [29, 30],
        [33, 34]]])

#Specific columns of all submatrices 3x3x3
doo[:,:,[0,1,3]]; #First, second and fourth cols of all submatrices
array([[[ 1,  2,  4],
        [ 5,  6,  8],
        [ 9, 10, 12]],

       [[13, 14, 16],
        [17, 18, 20],
        [21, 22, 24]],

       [[25, 26, 28],
        [29, 30, 32],
        [33, 34, 36]]])

#Selecting particular rows - the list is not exhaustible
#How to select particular rows of all submatrix
doo[[0,1,2],0]  #Select 1st (0th) row from each submatrix
array([[ 1,  2,  3,  4],
       [13, 14, 15, 16],
       [25, 26, 27, 28]])

doo[[0,1,2],1] #Select 2nd (1st) row from each submatrix
array([[ 5,  6,  7,  8],
       [17, 18, 19, 20],
       [29, 30, 31, 32]])

doo[[0,1,2],2] #Select 3rd (2nd) row from each submatrix
array([[ 9, 10, 11, 12],
       [21, 22, 23, 24],
       [33, 34, 35, 36]])

doo[[0,2],0]   #Select 1st (0th) row from first and last submatrix
array([[ 1,  2,  3,  4],
       [25, 26, 27, 28]])

doo[[0,2],1]   #Select 2nd (1st) row from first and last submatrix
array([[ 5,  6,  7,  8],
       [29, 30, 31, 32]])

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

doo = [1 + i for i in range(36)]

doo = np.reshape(doo,[3,3,4])

# 我们关联 3x3x4 数组中的所有示例

doo; # 我们也可以说 doo[:]

array([[[ 1, 2, 3, 4],

[ 5, 6, 7, 8],

[ 9, 10, 11, 12]],

[[13, 14, 15, 16],

[17, 18, 19, 20],

[21, 22, 23, 24]],

[[25, 26, 27, 28],

[29, 30, 31, 32],

[33, 34, 35, 36]]])

doo[0,] # 第 0 个子矩阵（第一个）

数组([[ 1, 2, 3, 4],

[ 5, 6, 7, 8],

[ 9, 10, 11, 12]])

doo[1,] # 第一个子矩阵（第二个）

数组([[13, 14, 15, 16],

[17, 18, 19, 20],

[21, 22, 23, 24]])

doo[2,] # 第二个子矩阵（第三个）

数组([[25, 26, 27, 28],

[29, 30, 31, 32],

[33, 34, 35, 36]])

doo[0:,0] ;# 每个子矩阵的第一行（第0行）

数组([[ 1, 2, 3, 4],

[13, 14, 15, 16],

[25, 26, 27, 28]])

doo[0:,1] ;# 每个子矩阵的第二行（第1行）

数组([[ 5, 6, 7, 8],

[17, 18, 19, 20],

[29, 30, 31, 32]])

doo[0:,2] ;# 每个子矩阵的第三行（第2行）

数组([[ 9, 10, 11, 12],

[21, 22, 23, 24],

[33, 34, 35, 36]])

#获取特定子矩阵的特定列

#doo[子矩阵,[行数组], 列]\

doo[0,[0,1,2],0] #第1个子矩阵，第0-2行，第0列，即第1个子矩阵的第1列

array([1, 5, 9])

doo[0,[0,1,2],1] #第1个子矩阵，第0-2行，第0列，即第1个子矩阵的第2列

数组([ 2, 6, 10])

doo[1,[0,1,2],0] #第2个子矩阵，第0-2行，第0列，即第2个子矩阵的第1列

数组([13, 17, 21])

doo[1,[0,1,2],1] #第2个子矩阵，第0-2行，第1列，即第2个子矩阵的第2列

数组([14, 18, 22])

#所有3x3子矩阵的特定列 - 请将其与3x4x3矩阵关联

doo[:,:,0] #所有子矩阵的第一列

数组([[ 1, 5, 9],

[13, 17, 21],

[25, 29, 33]])

doo[:,:,1] #所有子矩阵的第二列

数组([[ 2, 6, 10],

[14, 18, 22],

[26, 30, 34]])

#doo[:,:,2] #所有子矩阵的第三列

#doo[:,:,3] #所有子矩阵的第四列

#选择多列

#示例：每个子矩阵的第1列和第2列

doo[:,:,[0,1]]

数组([[[ 1, 2],

[ 5, 6],

[ 9, 10]],

[[13, 14],

[17, 18],

[21, 22]],

[[25, 26],

[29, 30],

[33, 34]]])

#所有3x3x3子矩阵的特定列

doo[:,:,[0,1,3]]; #所有子矩阵的第1、2和4列

数组([[[ 1, 2, 4],

[ 5, 6, 8],

[ 9, 10, 12]],

[[13, 14, 16],

[17, 18, 20],

[21, 22, 24]],

[[25, 26, 28],

[29, 30, 32],

[33, 34, 36]]])

#选择特定行 - 列表并非详尽无遗

#如何选择所有子矩阵的特定行

doo[[0,1,2],0] #从每个子矩阵中选择第1行（第0行）

数组([[ 1, 2, 3, 4],

[13, 14, 15, 16],

[25, 26, 27, 28]])

doo[[0,1,2],1] #从每个子矩阵中选择第2行（第1行）

数组([[ 5, 6, 7, 8],

[17, 18, 19, 20],

[29, 30, 31, 32]])

doo[[0,1,2],2] #从每个子矩阵中选择第3行（第2行）

数组([[ 9, 10, 11, 12],

[21, 22, 23, 24],

[33, 34, 35, 36]])

doo[[0,2],0] #从第一个和最后一个子矩阵中选择第1行（第0行）

数组([[ 1, 2, 3, 4],

[25, 26, 27, 28]])

doo[[0,2],1] #从第一个和最后一个子矩阵中选择第2行（第1行）

数组([[ 5, 6, 7, 8],

[29, 30, 31, 32]])

无论您称之为选择还是切片，都取决于您是使用索引还是切片运算符“:”。

无论采用何种过程，最终结果都是您想获得原始数据结构的子集。

3D切片和/或选择的应用是什么？

谢谢你
悉尼的Anthony

杰森·布朗利 2019年11月20日上午6:19 #

干得好！

安东尼·考拉 2020年6月17日下午3:25 #

尊敬的阿德里安博士，
我遇到了一个具有四个参数的数组拆分
我明白它在特定位置用0代替

#Don't worry about this, GOTO simplified fftShift[cY - size:cY + size, cX - size:cX + size] = 0 ;

1
2

#别担心这个，转到简化版
fftShift[cY - size:cY + size, cX - size:cX + size] = 0 ;

简化：通过替换a,b,c,d

fftShift[a: b, c: d] = 0 ;#substitute a 0, but was is a,b,c,d

1

fftShift[a: b, c: d] = 0 ;#替换为0，但a,b,c,d是什么

a, b, c, d 是什么？a,b,c,d 对行和列有什么影响？

谢谢你，
悉尼的安东尼，谢谢你，
悉尼的Anthony
杰森·布朗利 2020年6月18日上午6:20 #

是的，那是行的“从”和“到”，然后是列。

安东尼·考拉 2020年6月18日上午3:33 #

尊敬的Jason博士，
根据实验，a和b表示选择第a行到第b-1行，同时选择从第c列到第c-1列的剩余部分。
例如；

doo = np.reshape([i for i in range(100)],(10,10))
doo
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

doo = np.reshape([i for i in range(100)],(10,10))

doo

数组([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],

[20, 21, 22, 23, 24, 25, 26, 27, 28, 29],

[30, 31, 32, 33, 34, 35, 36, 37, 38, 39],

[40, 41, 42, 43, 44, 45, 46, 47, 48, 49],

[50, 51, 52, 53, 54, 55, 56, 57, 58, 59],

[60, 61, 62, 63, 64, 65, 66, 67, 68, 69],

[70, 71, 72, 73, 74, 75, 76, 77, 78, 79],

[80, 81, 82, 83, 84, 85, 86, 87, 88, 89],

[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

假设我们对doo执行了切片操作

doo[0:3,1:2]
array([[ 1],
       [11],
       [21]])

doo[0:3,1:4]
array([[ 1,  2,  3],
       [11, 12, 13],
       [21, 22, 23]])

doo[1:3,1:4]
array([[11, 12, 13],
       [21, 22, 23]])

doo[0:3,1:2]

数组([[ 1],

[11],

[21]])

doo[0:3,1:4]

数组([[ 1, 2, 3],

[11, 12, 13],

[21, 22, 23]])

doo[1:3,1:4]

数组([[11, 12, 13],

[21, 22, 23]])

如果我们给这些元素赋值

doo[1:3,1:4] = 0
doo[1:3,1:4] = 0
>>> doo
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10,  0,  0,  0, 14, 15, 16, 17, 18, 19],
       [20,  0,  0,  0, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

doo[1:3,1:4] = 0

>>> doo

数组([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],

[10, 0, 0, 0, 14, 15, 16, 17, 18, 19],

[20, 0, 0, 0, 24, 25, 26, 27, 28, 29],

[30, 31, 32, 33, 34, 35, 36, 37, 38, 39],

[40, 41, 42, 43, 44, 45, 46, 47, 48, 49],

[50, 51, 52, 53, 54, 55, 56, 57, 58, 59],

[60, 61, 62, 63, 64, 65, 66, 67, 68, 69],

[70, 71, 72, 73, 74, 75, 76, 77, 78, 79],

[80, 81, 82, 83, 84, 85, 86, 87, 88, 89],

[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])

回到

#Are two successive operations, one for columns and one for rows on the #variable doo the same? The answer is NO.
doo = np.reshape([i for i in range(100)],(10,10))
doo[1:3] = 0   ;#It does not matter the order of doing doo[1:3] = 0 or doo[:,1:4] =0
doo[:,1:4] = 0
doo
array([[ 0,  0,  0,  0,  4,  5,  6,  7,  8,  9],
       [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
       [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
       [30,  0,  0,  0, 34, 35, 36, 37, 38, 39],
       [40,  0,  0,  0, 44, 45, 46, 47, 48, 49],
       [50,  0,  0,  0, 54, 55, 56, 57, 58, 59],
       [60,  0,  0,  0, 64, 65, 66, 67, 68, 69],
       [70,  0,  0,  0, 74, 75, 76, 77, 78, 79],
       [80,  0,  0,  0, 84, 85, 86, 87, 88, 89],
       [90,  0,  0,  0, 94, 95, 96, 97, 98, 99]])

#在变量doo上，对列进行一次操作，对行进行一次操作，两者是否相同？答案是NO。

doo = np.reshape([i for i in range(100)],(10,10))

doo[1:3] = 0 ;#执行doo[1:3] = 0或doo[:,1:4] =0的顺序无关紧要

doo[:,1:4] = 0

doo

数组([[ 0, 0, 0, 0, 4, 5, 6, 7, 8, 9],

[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[30, 0, 0, 0, 34, 35, 36, 37, 38, 39],

[40, 0, 0, 0, 44, 45, 46, 47, 48, 49],

[50, 0, 0, 0, 54, 55, 56, 57, 58, 59],

[60, 0, 0, 0, 64, 65, 66, 67, 68, 69],

[70, 0, 0, 0, 74, 75, 76, 77, 78, 79],

[80, 0, 0, 0, 84, 85, 86, 87, 88, 89],

[90, 0, 0, 0, 94, 95, 96, 97, 98, 99]])

总而言之，执行切片操作

#We are doing the substitution at the intersection of the rows and the columns
doo[1:3,1:4] = 0
#We are substituting on the particular rows and the particular columns
doo[1:3] = 0   ;# Select the rows 
doo[:,1:4] = 0 ;# Select the columns

#我们正在行的交集和列的交集处进行替换

doo[1:3,1:4] = 0

#我们正在特定行和特定列上进行替换

doo[1:3] = 0 ;# 选择行

doo[:,1:4] = 0 ;# 选择列

我希望能穷尽所有可能的索引切片方法

谢谢你，
悉尼的Anthony

spankwire 2019年11月30日上午4:37 #

在更高级的用例中，您可能需要切换某个矩阵的维度。在机器学习应用中，这通常是模型期望的输入形状与数据集不同时的情况。NumPy 的

回复
- 杰森·布朗利 2019年11月30日上午6:32 #
  
  是的，我想我在这里用moveaxis()和图像给出了例子
  https://machinelearning.org.cn/a-gentle-introduction-to-channels-first-and-channels-last-image-formats-for-deep-learning/
  
  回复
伊扬达·塔奥菲克 2019年12月13日上午10:06 #

请问我如何将一维数组转换为七维数组？

回复
- 杰森·布朗利 2019年12月13日下午1:42 #
  
  您可以使用 reshape() 函数指定现有 numpy 数组的维度。
  
  回复
普拉蒂克·查夫汉 2020年1月10日上午3:24 #

Numpy切片和重塑的优秀工作流程……从您的文章中获得了大量知识……这在我的工作中帮助了我很多……谢谢

回复
- 杰森·布朗利 2020年1月10日上午7:29 #
  
  很高兴听到这个！
  
  回复
阿列克谢 2020年2月28日上午8:22 #

解释得比Stack Overflow好。谢谢你，伙计)

回复
- 杰森·布朗利 2020年2月28日下午1:24 #
  
  谢谢！
  
  回复
西哈姆 2020年3月13日上午1:46 #

多么棒的教程，非常感谢您的出色工作。继续保持好工作

回复
- 杰森·布朗利 2020年3月13日上午8:19 #
  
  谢谢，很高兴它有帮助！
  
  回复
拉金德兰 2020年5月21日下午9:37 #

本教程真的很有帮助。非常感谢。我的数据集是3维数组，例如（样本数，行数，列数），我如何将其作为输入提供给RNN？因为RNN接受的输入是（样本，时间步，特征），对吗？

回复
- 杰森·布朗利 2020年5月22日上午6:07 #
  
  不客气。
  
  好问题，请看这个
  https://machinelearning.org.cn/faq/single-faq/what-is-the-difference-between-samples-timesteps-and-features-for-lstm-input
  
  回复
Winner 2020年6月11日上午4:44 #

“如何为机器学习索引、切片和重塑NumPy数组”

好的，我为此已经努力了数周……，仔细阅读您的帖子，然后试图弄清楚您是如何做到的，尤其是当代码无法在我的系统上顺利运行时。
但这篇文章最雄辩地解释了我过去几周所面临问题的根源。
这与我缺乏对不同Python“库”和网络模型需要不同数据格式进行输入/输出的理解/知识有关。
今天我找到了这篇帖子，它为像我这样的初学者解释了数据准备的基础知识。
非常感谢。
我有三个问题要问您
1.
这些都在你的书里吗？
2.
您能否重新设计这个网站，以便在左侧边栏显示一个网站的“目录”，类似于（https://pandas.ac.cn/docs/getting_started/intro_tutorials/index.html），从初级水平开始？这将肯定有助于导航和故障排除。我需要花费数小时才能找到我正在寻找的一些答案，而它们就在我的眼皮底下。
3.
你有你的书的纸质版吗？

Winner

回复
- 杰森·布朗利 2020年6月11日上午6:04 #
  
  我在这本书中介绍了数组索引/操作的基础知识
  https://machinelearning.org.cn/linear_algebra_for_machine_learning/
  
  很好的建议，这可能有所帮助
  https://machinelearning.org.cn/start-here/
  
  关于硬拷贝
  https://machinelearning.org.cn/faq/single-faq/can-i-get-a-hard-copy-of-your-book
  
  回复
韩 2020年6月12日下午7:19 #

非常感谢杰森！这对我这个初学者来说非常清晰和有帮助。只是想检查一下这句话中是否有打字错误：“通常需要将一维数组重塑为一列多行（原文如此）的二维数组。” 您是指*行吗？

回复
- 杰森·布朗利 2020年6月13日上午5:56 #
  
  谢谢，已修复！
  
  回复
毫米 2020年10月16日上午10:35 #

如何从文本框 tkinter 输入矩阵值

回复
- 杰森·布朗利 2020年10月16日下午1:49 #
  
  tkinter 是什么？
  
  回复
  - 毫米 2020年10月29日上午10:47 #
    
    我的意思是如何通过图形界面创建numpy数组和数组值用户干预
    
    回复
    - 杰森·布朗利 2020年10月29日下午1:42 #
      
      抱歉，我没有任何关于使用图形界面创建numpy数组的教程。
      
      回复
阿里尔 2021年1月5日下午5:51 #

一篇非常好的教程。有一个可以改进的地方：我会添加几句关于 train-test-split() 方法的说明，或者提供一些参考文献的链接，比如下面的这个
https://realpython.com/train-test-split-python-data/

回复
- 杰森·布朗利 2021年1月6日上午6:24 #
  
  你可以在这里了解更多
  https://machinelearning.org.cn/train-test-split-for-evaluating-machine-learning-algorithms/
  
  回复
engimp 2021年3月13日上午4:04 #

一流的贡献，谢谢你

回复
- 杰森·布朗利 2021年3月13日上午5:34 #
  
  谢谢！
  
  回复
纪尧姆 2021年4月9日下午3:21 #

嗨，Jason，

从一个形状中检索一维索引的最佳方法是什么？假设我有一个由2个变量组成的状态，它们被分成(20, 30)个bin，我想构建一个形状为(600, 3)的Q值表。

我需要经常将二维索引转换为一维索引。例如，从[1, 2]到1*20 + 2 = 22。我们有什么方法可以在numpy中轻松做到这一点吗？

我能想到的只有
如果 dims = [20, 30]
dims[-1] = 1
以及 idx = np.dot(dims, state_idx)，其中 state_idx = [1, 2] 例如

有没有更优雅的方法

回复
- 杰森·布朗利 2021年4月10日上午6:02 #
  
  抱歉，我不明白你的问题。
  
  也许可以尝试发布到stackoverflow。
  
  回复
K PRASANTH 2021年5月17日下午10:49 #

嗨，Jason，

1. 我该如何解决层不兼容和数组数据重塑的问题？
2. 在 LSTM 中，哪些参数可以提高模型的准确性，例如优化器、度量等？

回复
- 杰森·布朗利 2021年5月18日上午6:15 #
  
  也许你可以使用重塑层？
  
  本网站的这部分内容是关于提高模型性能的
  https://machinelearning.org.cn/start-here/#better
  
  回复
克雷格M 2021年11月20日上午12:45 #

嗨，Jason，

我正在尝试将两个未知大小的二维数组相乘，同时保留最大数组中的最后一列并将其复制到新的结果数组中。例如

数组 A = [1,2,3,4,5]
[6,7,8,9,10]
[11,12,13,14,15]

数组 B = [1,2,3,4]
[6,7,8,9,]
[11,12,13,14]

C = A x B，形状保持 3,5，其中第 5 列为 5,10,15

我知道索引使用特定位置，但是有没有办法使用第 n 个位置将其拆分为子数组？我希望将数组 A 拆分为一个子数组（在这种情况下是 4 列）以执行乘法。

或者，有没有办法在较小数组的最后一列中插入 1，使它们大小相同，从而得到相同的结果。

非常感谢任何帮助。

此致，
克雷格

回复
- 阿德里安·谭 2021年11月20日上午2:42 #
  
  您所说的肯定不是矩阵乘法。如果您想进行元素乘法，可以这样做
  
  C = A.copy() C[:, :4] = C[:, :4] * B
  
  1
  2
  
  C = A.copy()
  C[:, :4] = C[:, :4] * B
  
  您必须使用切片使 C 的形状与 B 完全相同
  
  回复
特斯法耶 2022年8月20日下午10:17 #

感谢您在机器学习和深度学习方面所做的工作，这很有帮助。

回复
- 詹姆斯·卡迈克尔 2022年8月21日上午7:50 #
  
  非常欢迎 Tesfaye！我们祝您在机器学习之旅中一切顺利！
  
  回复

导航

如何为机器学习索引、切片和重塑 NumPy 数组

教程概述

在机器学习线性代数方面需要帮助吗？

1. 从列表到数组

一维列表到数组

二维列表到数组

2. 数组索引

一维索引

二维索引

3. 数组切片

一维切片

二维切片

拆分输入和输出特征

拆分训练和测试行

4. 数组重塑

数据形状

将 1D 重塑为 2D 数组

将 2D 重塑为 3D 数组

进一步阅读

总结

掌握机器学习线性代数！

建立对线性代数的工作理解

最终理解数据的数学

关于此主题的更多信息

对如何为机器学习索引、切片和重塑 NumPy 数组的 102 条回复

发表评论点击此处取消回复。

导航

教程概述

在机器学习线性代数方面需要帮助吗？

1. 从列表到数组

一维列表到数组

二维列表到数组

2. 数组索引

一维索引

二维索引

3. 数组切片

一维切片

二维切片

拆分输入和输出特征

拆分训练和测试行

4. 数组重塑

数据形状

将 1D 重塑为 2D 数组

将 2D 重塑为 3D 数组

进一步阅读

总结

掌握机器学习线性代数！

建立对线性代数的工作理解

最终理解数据的数学

关于此主题的更多信息

对如何为机器学习索引、切片和重塑 NumPy 数组的 102 条回复

发表评论 点击此处取消回复。

发表评论点击此处取消回复。