精华内容
下载资源
问答
  • numpy 数组shape()

    2020-07-27 17:22:28
    # 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.数组中数据...


    不知道大家有没有类似的问题,处理数据的时候很多时候会被各种数组的 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([...
  • Numpy中一维数组shape如何理解

    千次阅读 2019-01-29 11:17:00
  • Numpy入门之数组shape

    2020-07-09 18:19:29
    假设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的理解

    万次阅读 多人点赞 2018-10-30 11:38:32
    python 三维数组,numpy中np.shape的应用...直接贴图对于shape函数一般表示输出数组的形状,对于二维数组就是输出行与列,对于三维数组shape[0]表示三维数组中包含多少个二维数组,后两个数字表示二维数组的形状 ...
  • Python中numpy数组shape与reshape函数

    千次阅读 2019-05-12 22:26:55
    np.shape()与np.reshape()函数 参考博文:https://blog.csdn.net/qq_28618765/article/details/78083895 最近,主要在做一些数据分析与机器视觉相关项目,经常使用到np.reshape(),np.reshape()函数。虽然对它们有...
  • Numpy数组的形状(shape)操作 首先,使用 ndarray.shape 可以返回数组的形状 改变Numpy数组形状的方法 以下的操作均不改变原数组,而是返回一个新的更改后的数组: ndarray.ravel(): 返回展平后的数组,按照一行跟...
  • Python shape函数获取数组大小

    千次阅读 2018-07-11 09:57:50
     数组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#编程中一维数组与多维数组的使用,包括数组初始化等基础知识的讲解,需要的朋友可以参考下
  • tensorflow 关于张量 shape 数组

    千次阅读 2018-05-20 12:21:11
    你可以把一个张量想象成一个n维的数组或列表.一个张量有一个静态类型和动态类型的维数.张量可以在图中的节点之间流通.阶在TensorFlow系统中,张量的维数来被描述为阶.但是张量的阶和矩阵的阶并不是同一个概念.张量的...
  • 注:空向量,shape为 ([0]) ;空数组shape为([ ]) 。 附:
  • Numpy 创建数组

    2019-04-17 02:40:52
    创建指定大小的数组数组元素以 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学习之创建数组

    千次阅读 2019-10-26 09:37:37
    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<=...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,094
精华内容 35,637
关键字:

数组shape