• # t1 一维数组 t1 = np.arange(12) print(t1,t1.shape) # 查看数组的形状 print(t1.shape) # t1 二维数组 t2 = np.array([[1,2,3],[4,5,6]]) print(t2,t2.shape) # t3 三维数组 t3 = np.array([[[1,2,3],[4,5,6]]...
import numpy as np

# t1 一维数组
t1 = np.arange(12)
print(t1,t1.shape)

# 查看数组的形状
print(t1.shape)

# t1 二维数组
t2 = np.array([[1,2,3],[4,5,6]])
print(t2,t2.shape)

# t3 三维数组
t3 = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(t3,t3.shape)

# 结果
[ 0  1  2  3  4  5  6  7  8  9 10 11] (12,)
(12,)
[[1 2 3]
[4 5 6]] (2, 3)
[[[ 1  2  3]
[ 4  5  6]]
[[ 7  8  9]
[10 11 12]]] (2, 2, 3)

t4 = np.arange(12)
...: print(t4,t4.shape)
[ 0  1  2  3  4  5  6  7  8  9 10 11] (12,)
t4.reshape((3,4))
Out[4]:
array([[ 0,  1,  2,  3],
[ 4,  5,  6,  7],
[ 8,  9, 10, 11]])
t5 = np.arange(24).reshape((2,3,4))
...: print(t5)
[[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]

#  一维数组转化为三维数组
t5 = np.arange(24).reshape((2,3,4))
print(t5)

[[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]

#  t5 三维数组转化为一维数组
t5.reshape((24,))

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])

#  t5 三维数组转化为二维数组
t5.reshape((24,1))

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]])

#  t5 三维数组转化为二维数组
t5.reshape((1,24))

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]])

# 当数组t5的维数未知时，可采用shape属性的数组结果下标来计算t5的元素个数转化为一维数组
t6 = t5.reshape((t5.shape[0]*t5.shape[1]*t5.shape[2],))
print(t6)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

#  当数组t5的维数未知时，可采用flatten()转化为一维数组
t5.flatten()

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])


展开全文
• ## numpy多维数组shape的理解

千次阅读 多人点赞 2019-03-29 15:43:51
想了很多都没有找到简明的描述,找规律的话,大家一看就明白了 (2,3) 表示两个一维数组,每个一维数组长度为3...(2,3,4,5) 表示两个三维数组,每个三维数组有3个二维数组,每个二维数组有4个一维数组,一维数组长度为5 ...
想了很多都没有找到简明的描述,找规律的话,大家一看就明白了
(2,3) 表示两个一维数组,每个一维数组长度为3(2,3,4) 表示两个二维数组,每个二维数组有3个一维数组,每个一维数组长度为4(2,3,4,5) 表示两个三维数组,每个三维数组有3个二维数组,每个二维数组有4个一维数组,一维数组长度为5
展开全文
• 文章目录1.数组中数据存储的结构2....不知道大家有没有类似的问题，处理数据的时候很多时候会被各种数组shape 的变化搞晕，但是这方面的资料又不太好找，这里记录一点我遇到的这方面的知识点。 1.数组中数据...


文章目录
1.数组中数据存储的结构2.数组的坐标问题3.对于Pytorch 的shape相关问题4. Pytorch 中几个常见的有关维度的函数4.1 squeeze() 和 unsqueeze()4.2 permute() 函数4.3 transpose()函数

不知道大家有没有类似的问题，处理数据的时候很多时候会被各种数组的 shape 的变化搞晕，但是这方面的资料又不太好找，这里记录一点我遇到的这方面的知识点。

1.数组中数据存储的结构
首先从数据的排列来看，从一个简单的例子来看：
a = np.linspace(1, 24, 24).reshape(2, 3, 4)
print(a)

# 输出结果：
[[[ 1.  2.  3.  4.]
[ 5.  6.  7.  8.]
[ 9. 10. 11. 12.]]

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

首先 1 - 24 的24个数字，排列成 shape 为 (2, 3, 4) 的数组，可以看到这种数据排列的方式显然是按照从最低维（这里是一个三维数组，0，1，2）2开始排列数据，这样至少确定了在进行reshape的时候数据是如何填充的，我的猜想是reshape可以看作是两步：
1.首先将数组整个拉平（既然填充的时候是现在高维度上进行填充，那么拉平的过程就是反向的了）然后按照新的 shape 按照上面的方式进行填充
2.数组的坐标问题
举个例子来看非常明显：
a = np.linspace(1, 24, 24).reshape(2, 3, 4)

print(a[1][0][0])
print(a[0][1][0])
print(a[0][0][1])

# 可以看到输出分别为：
13.0
5.0
2.0

也就是最低维是行(向下增加)，第二维是列，第三维是深。
3.对于Pytorch 的shape相关问题
Numpy 中的数组 array 也就是对应 Pytorch 的 tensor ，那么上面的方式应该在 pytorch 中也是适用的，测试：
b = torch.from_numpy(a)
print(b)
print(b[1][0][0])
print(b[0][1][0])
print(b[0][0][1])

# 输出为：
tensor([[[ 1.,  2.,  3.,  4.],
[ 5.,  6.,  7.,  8.],
[ 9., 10., 11., 12.]],

[[13., 14., 15., 16.],
[17., 18., 19., 20.],
[21., 22., 23., 24.]]], dtype=torch.float64)
tensor(13., dtype=torch.float64)
tensor(5., dtype=torch.float64)
tensor(2., dtype=torch.float64)

测试一下 Pytorch 的 reshape 的函数，Pytorch 中经常使用 view（）函数来进行改变数组的 size：
c = b.view(4, 3, 2)
print(c)

# 输出结果：
tensor([[[ 1.,  2.],
[ 3.,  4.],
[ 5.,  6.]],

[[ 7.,  8.],
[ 9., 10.],
[11., 12.]],

[[13., 14.],
[15., 16.],
[17., 18.]],

[[19., 20.],
[21., 22.],
[23., 24.]]], dtype=torch.float64)

确实与 Numpy 的 reshape 方式一致
4. Pytorch 中几个常见的有关维度的函数
4.1 squeeze() 和 unsqueeze()
这是一对操作相反的函数，分别用于 降维/升维 操作，例如：
a = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(a.size())
print(a)

b = a.unsqueeze(0)
print(b.size())
print(b)

# 输出结果为：
torch.Size([2, 3])
tensor([[1, 2, 3],
[4, 5, 6]])

torch.Size([1, 2, 3])
tensor([[[1, 2, 3],
[4, 5, 6]]])

两个函数都需要传入 dim 参数，指定在哪一个维度上进行 压缩 或者 升维，上面的例子中可以看到在第0维上增加了一个维度。当然这对数据本身并没有什么改变，但是 Pytorch 中对输入的数据格式都做了要求，往往要求是一个四元组，所以很多时候都要对原始数据进行一些改变，所以就用得到这个函数了。
与之对应：
c = b.squeeze(0)
print(c.size())
print(c)

# 输出：
torch.Size([2, 3])
tensor([[1, 2, 3],
[4, 5, 6]])


不过因为是压缩，所以只有在维度为1的时候才生效。
4.2 permute() 函数
从函数名就可以看出这个函数用于重新排列，这与 reshape 之类的函数区别就在于这是是直接进行重新排列，例如：
对于 [[1, 2],
[3, 4],
[5, 6]]

a = torch.tensor([[1, 2], [3, 4], [5, 6]])
b = a.permute(1, 0)

print(b)
# 输出：
tensor([[1, 3, 5],
[2, 4, 6]])

可以看到这是相当于进行了一个转置，也就是维度上的重新排列，如果得到 (2, 3) 的数组，使用view（）函数则是：
c = a.view(2, 3)
print(c)

# 输出：
tensor([[1, 2, 3],
[4, 5, 6]])

可以很明显地看到区别。
对于二维的数据，这个函数就是简单地转置，但是对于三维数据，有点抽象，举个例子来说：
a = torch.arange(1, 25)
a = a.view(2, 3, 4)

print(a)
b = a.permute(2, 1, 0)

print(b)

# 输出结果：

tensor([[[ 1,  2,  3,  4],
[ 5,  6,  7,  8],
[ 9, 10, 11, 12]],

[[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24]]])
tensor([[[ 1, 13],
[ 5, 17],
[ 9, 21]],

[[ 2, 14],
[ 6, 18],
[10, 22]],

[[ 3, 15],
[ 7, 19],
[11, 23]],

[[ 4, 16],
[ 8, 20],
[12, 24]]])

这里相当于将所有的维度进行了相反的排列，看数据的排列就会发现这就像是矩阵的立体结构进行了旋转，但是内部的数据排列又要改变位置，总之数据要符合原来的排列顺序，这个也称它为高维矩阵的转置，也就是熟知的二维数据转置的推广。（这已经超越我语言的极限了…╮（╯＿╰）╭），基本就是这个意思。
更详细的可以参考：Pytorch之permute函数
4.3 transpose()函数
transpose()函数是经常使用的转置函数，用于。。。转置 (￣_￣|||) 但是与上面提到的 permute 函数不同的是， transpose 函数只能在两个维度上进行转置，所以如果某次操作涉及三个以及更多维度的转置的话，使用 permute 函数更方便，当然，连续使用多次 transpose 函数也可以达到同样的目的，例如：
a = torch.randn(2, 3, 4)

# transpose() 函数可以进行两个维度的转置 所以连续使用多次transpose()函数等同于对应的permute()函数
b = a.permute(1, 2, 0)
c = a.transpose(0, 1)
c = c.transpose(1, 2)

print(b.equal(c))

print(b.size())
print(c.size())

输出：
True
torch.Size([3, 4, 2])
torch.Size([3, 4, 2])

可以看到，两种函数实现了一样的结果。
展开全文
• a.shape为(3,)， 注意逗号后面是空，则表示一维数组。 b = np.array([[1,2,3]]) 的结果是array([[1, 2, 3]])。 两个中括号[[]]， 表示为二维数组。 其shape为(1, 3)，即1行3列。 当一维数组a 与二维数组b进行操作a-...
a = np.array([1,2,3])

的结果是array([1, 2, 3])。其表示一维数组。
a.shape为(3,)， 注意逗号后面是空，则表示一维数组。
b = np.array([[1,2,3]])

的结果是array([[1, 2, 3]])。 两个中括号[[]]， 表示为二维数组。 其shape为(1, 3)，即1行3列。
当一维数组a 与二维数组b进行操作a-b时，会把a扩展维二维数组，因为两个都是1行三列，其结果仍为1行三列。 array([[0, 0, 0]])。
但如果是 a-c 或者 b-c， 因为前者是一行三列，后者是一列三行，所以结果会扩展成3行3列。 即
a - c

array([[ 0, 1, 2], [-1, 0, 1], [-2, -1, 0]])
b - c

array([[ 0, 1, 2], [-1, 0, 1], [-2, -1, 0]])
大家在日常操作中一定要注意相关操作。
展开全文
• 今天，我们将会学习数组shape属性，并更深入地了解数组特别是多维数组的表示方式。 1、shape属性 数组shape属性就如同它的名字一样，反映的是数组的“形状”。 对于一维数组，反映的是一个维度上的元素数量，...
• 关于Numpy数组中属性shape的理解 概述：numpy数组都有着shape这一属性，怎么理解这一属性呢？看以下代码： # 关于numpy中shape参数的深刻理解 p1 = np.array([1, 2, 3]) p2 = np.array([[1], [2]]) p3 = np.array([...
• 假设a是一个数组： a = np.array([[1,2,3],[4,...那么他调用**a.shape()**函数的时候输出为 (2, 3) 表示为他有***两行三列*** 那么如果a数组是三维的，比如说 a = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
• 在这里，首先定义一个简单的二维数组，如下： >>> import numpy as np >>> a=np.array([[1,2],[3,4],[5,6]]) >>> type(a) <type 'numpy.ndarray'> >>> a.shape (3, 2) &...
• demo.py（shape形状，reshape改变形状，多维数组）： # coding=utf-8 import numpy as np # shape属性(形状) t1 = np.array([1, 2, 3, 4, 5]) # 一维数组 print(t1.shape) # (5,) 5个元素 t2 = np.array([[1, ...
• python 三维数组，numpy中np.shape的应用...直接贴图对于shape函数一般表示输出数组的形状，对于二维数组就是输出行与列，对于三维数组shape[0]表示三维数组中包含多少个二维数组，后两个数字表示二维数组的形状 ...
• np.shape()与np.reshape()函数 参考博文：https://blog.csdn.net/qq_28618765/article/details/78083895 最近，主要在做一些数据分析与机器视觉相关项目，经常使用到np.reshape(),np.reshape()函数。虽然对它们有...
• Numpy数组的形状（shape）操作 首先，使用 ndarray.shape 可以返回数组的形状 改变Numpy数组形状的方法 以下的操作均不改变原数组，而是返回一个新的更改后的数组： ndarray.ravel(): 返回展平后的数组，按照一行跟...
•  数组shape属性常用语获取一个数组的当前大小，与reshape函数相似，shape函数也可以更改数组大小，其中一个维度的大小可为-1，表明该处大小从数组的原size和剩余dimensions推算而来。示例： 最后一个示例没看懂...
• tf.matmul（）是常见的矩阵相乘运算，而... 像shape=[a,b,c]，就可以理解为底面积是[b,c],高是a，更准确的理解这个数组共是a页，每一页都有一个b行c列的二维数组，可以说a个b*c的二维数组构成了这个[a,b,c]的三维数组
• https://blog.csdn.net/zhouheng2018/article/details/70196664#21-功能 L = length(data) data=[1 2 3] 查看数组长度 L = 3
• numpy数组array的shape属性-1维、2维··· numpy 创建的数组都有一个shape属性，它是一个元组，返回各个维度的维数。有时候我们可能需要知道某一维的特定维数。 一维情况 二维 可以看到y是一个两行三列的二维...
• 主要介绍了详解C#编程中一维数组与多维数组的使用,包括数组初始化等基础知识的讲解,需要的朋友可以参考下
• 你可以把一个张量想象成一个n维的数组或列表.一个张量有一个静态类型和动态类型的维数.张量可以在图中的节点之间流通.阶在TensorFlow系统中，张量的维数来被描述为阶.但是张量的阶和矩阵的阶并不是同一个概念.张量的...
• 注：空向量，shape为 ([0]) ；空数组shape为([ ]) 。 附：
• 创建指定大小的数组数组元素以 0 来填充： numpy.zeros(shape, dtype = float, order = 'C') 参数说明： 参数 描述 shape 数组形状 dtype 数据类型，可选 order 'C' 用于 C 的行数组，或者 ...
• Numpy 数组属性 2.1 shape 属性 shape 属性返回数组的形状信息，是一个元组对象。 In [118]: a = np.zeros(5) In [120]: b = np.ones((2, 3)) In [121]: a Out[121]: array([0., 0., 0., 0., 0.]) In [122]: b Out...
• numpy学习之创建数组 教程：菜鸟教程----Numpy 菜鸟教程----Python 1.使用array函数创建数组 import numpy as np ndarray1 = np.array([1, 2, 3]) array([1, 2, 3]) ndarray2 = np.array(list('abcd')) ...
• numpy 不同形状(shape)的数组数值计算方式 1.如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。 import numpy as ...
• python--Numpy-- 如何根据array的结果看数据 shape先上结果解释（根据array看 shape） 先上结果 #打印x的结果如下： print(x.shape) (7,3,2)#输出维度结果 解释（根据array看 shape） 1、根据[ ]层数确定有几维...
• ## numpy.array 的shape属性理解

万次阅读 多人点赞 2018-02-27 10:14:10
简介numpy 创建的数组都有一个shape属性，它是一个元组，返回各个维度的维数。有时候我们可能需要知道某一维的特定维数。
• 主要用到shape, reshape函数我们先搞清np.ndarrayd数组的特点import numpy as np ex = np.arange(0,12,1) ex # 括号里的0可以省略，也可以换成其他起始数，1是步长。运行上述代码，我们 # 发现ex只是一个序列并没有...
• 洋葱剥离法例如：给定了以下array（矩阵） a，要你立即读出它的shape大小，该怎么读？？？a=array([[[[ 1., 2.]],[[ 3., 4.]],[[ 5., 6.]]],[[[ 7., 8.]],[[ 9., 10.]],[[ 11., 12.]]],[[[ 13., 14.]],[[ 15., 16.]]...
• 数组.shape=(转换为x行，转换为y列) ：一维/多维 转 多维/一维 原数组.reshape(转换为x行，转换为y列)：一维/多维 转 多维/一维 import numpy as np print("----------------np.floor()向下取整------------....
• 根据变换条件生成新数组(新数组shape与原数组相同) 下面简单总结. 生成子数组 情况1 已知数组a，以及若干筛选条件conds，要求从数组a中生成一个子数组b。 解决办法：b=a[conds]。比如b=a[a>0],b=a[(a>=1)|(a<=...

...